node-red-contrib-velbus-2026 0.8.1

package/nodes/velbus-blind-s/velbus-blind-s.js

@@ -0,0 +1,282 @@
+'use strict';
+
+const { pkt, parsePkt } = require('../../lib/velbus-utils');
+const { BLIND_TYPES_S, BLIND_TYPE_IDS_S } = require('../../lib/blind-types-s');
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+const BLIND_STATUS = { 0: 'off', 1: 'up', 2: 'down' };
+
+const LOCK_STATUS = {
+  0: 'normal', 1: 'inhibited', 2: 'inhibit_preset_down',
+  3: 'inhibit_preset_up', 4: 'forced_down', 5: 'forced_up', 6: 'locked',
+};
+
+function make24(duration) {
+  return [(duration >> 16) & 0xFF, (duration >> 8) & 0xFF, duration & 0xFF];
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Node
+// ─────────────────────────────────────────────────────────────────────────────
+
+module.exports = function(RED) {
+
+  function VelbusBlindSNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    node.bridge     = RED.nodes.getNode(config.bridge);
+    node.address    = typeof config.address === 'number'
+      ? config.address  // legacy saves stored decimal numbers
+      : (parseInt(config.address, 16) || 0);  // editor stores hex strings
+    node.moduleName = config.moduleName || '';
+    node.typeId     = config.typeId ? parseInt(config.typeId) : null;
+    node.channel    = parseInt(config.channel) || 1;
+
+    if (!node.bridge) {
+      node.status({ fill: 'red', shape: 'ring', text: 'no bridge' });
+      node.error('velbus-blind-s: no bridge configured');
+      return;
+    }
+    if (!node.address || node.address < 1 || node.address > 254) {
+      node.status({ fill: 'red', shape: 'ring', text: 'invalid address' });
+      node.error('velbus-blind-s: invalid address ' + node.address);
+      return;
+    }
+
+    const typeDesc = node.typeId !== null ? (BLIND_TYPES_S[node.typeId] || null) : null;
+    // Channel bit: ch1=0x01, ch2=0x02 for both VMB1BLS and VMB2BLE
+    const chBit = typeDesc ? (typeDesc.channelBits[node.channel] || 0x01) : 0x01;
+
+    // 0x00 relay event bitmask for this channel
+    // ch1: up=bit0, down=bit1; ch2: up=bit2, down=bit3
+    const relayUpBit   = node.channel === 1 ? 0x01 : 0x04;
+    const relayDownBit = node.channel === 1 ? 0x02 : 0x08;
+
+    const _addrHex = '0x' + node.address.toString(16).padStart(2, '0').toUpperCase();
+    function setStatus(text, fill, shape) {
+      const label = node.moduleName
+        ? node.moduleName + ' ch' + node.channel + ' (' + _addrHex + ')'
+        : _addrHex + ' ch' + node.channel;
+      node.status({ fill: fill || 'green', shape: shape || 'dot', text: label + ' ' + text });
+    }
+
+    // ── Packet handler ────────────────────────────────────────────────────
+
+    function onPacket(raw) {
+      const p = parsePkt(raw);
+      if (!p || p.rtr) return;
+      if (p.addr !== node.address) return;
+
+      const { cmd, body } = p;
+
+      switch (cmd) {
+
+        // ── 0x00  Relay switch events ─────────────────────────────────────
+        case 0x00: {
+          if (body.length < 4) return;
+          // body[0]=cmd, body[1]=switched on, body[2]=switched off, body[3]=0x00
+          const pressedByte   = body[1];
+          const releasedByte  = body[2];
+
+          const upOn    = !!(pressedByte  & relayUpBit);
+          const upOff   = !!(releasedByte & relayUpBit);
+          const downOn  = !!(pressedByte  & relayDownBit);
+          const downOff = !!(releasedByte & relayDownBit);
+
+          if (!upOn && !upOff && !downOn && !downOff) return;
+
+          const direction = upOn ? 'up' : downOn ? 'down' : null;
+          const stopped   = upOff || downOff;
+          if (direction) setStatus(direction);
+          else if (stopped) setStatus('stopped');
+
+          const payload = {
+            type:      'blind_event',
+            channel:   node.channel,
+            upOn,
+            upOff,
+            downOn,
+            downOff,
+            moving:    direction,
+          };
+          node.send([{ payload }, null]);
+          break;
+        }
+
+        // ── 0xEC  Blind status ────────────────────────────────────────────
+        case 0xEC: {
+          if (body.length < 8) return;
+          // body[0]=0xEC, body[1]=channel bit, body[2]=default timeout (seconds),
+          // body[3]=blind status, body[4]=LED status, body[5]=position (0-100%),
+          // body[6]=lock/inhibit/forced state, body[7]=alarm & auto mode
+
+          if (body[1] !== chBit) return;
+
+          const blindStatus   = BLIND_STATUS[body[3]] || 'unknown';
+          const position      = body[5];  // 0=up, 100=down
+          const lockState     = LOCK_STATUS[body[6] & 0x07] || 'unknown';
+
+          const alarmByte = body[7];
+          const autoMode       = alarmByte & 0x03;
+          const alarm1Active   = !!(alarmByte & 0x04);
+          const alarm2Active   = !!(alarmByte & 0x10);
+          const sunriseEnabled = !!(alarmByte & 0x40);
+          const sunsetEnabled  = !!(alarmByte & 0x80);
+
+          const ledByte = body[4];
+          const led = {
+            downOn:        !!(ledByte & 0x80),
+            downSlowBlink: !!(ledByte & 0x40),
+            downFastBlink: !!(ledByte & 0x20),
+            downVFastBlink:!!(ledByte & 0x10),
+            upOn:          !!(ledByte & 0x08),
+            upSlowBlink:   !!(ledByte & 0x04),
+            upFastBlink:   !!(ledByte & 0x02),
+            upVFastBlink:  !!(ledByte & 0x01),
+          };
+
+          const on = blindStatus !== 'off';
+          setStatus(blindStatus + ' ' + position + '%');
+
+          const payload = {
+            type:      'blind_status',
+            channel:   node.channel,
+            on,
+            status:    blindStatus,
+            position,
+            lockState,
+            autoMode,
+            alarms: { alarm1Active, alarm2Active },
+            sunrise: sunriseEnabled,
+            sunset:  sunsetEnabled,
+            led,
+          };
+          node.send([null, { payload }]);
+          break;
+        }
+
+        // ── 0xF0/F1/F2  Blind name parts ─────────────────────────────────
+        case 0xF0:
+        case 0xF1:
+        case 0xF2: {
+          // body[0]=cmd, body[1]=channel bit, body[2..]=chars
+          if (body[1] !== chBit) return;
+          let text = '';
+          for (let i = 2; i < body.length; i++) {
+            if (body[i] === 0 || body[i] === 0xFF) break;
+            text += String.fromCharCode(body[i]);
+          }
+          if (text && cmd === 0xF0) node.moduleName = text;
+          break;
+        }
+
+        default:
+          break;
+      }
+    }
+
+    node.bridge.register(node.address, onPacket);
+
+    // ── Input commands ────────────────────────────────────────────────────
+
+    node.on('input', function(msg) {
+      const cmd = msg.payload && msg.payload.cmd;
+      if (!cmd) return;
+
+      if (cmd === 'get_status') {
+        node.bridge.send(pkt(0xFB, node.address, [0xFA, chBit]));
+        return;
+      }
+      if (cmd === 'stop') {
+        node.bridge.send(pkt(0xF8, node.address, [0x04, chBit]));
+        return;
+      }
+      if (cmd === 'up') {
+        const timeout = parseInt(msg.payload.timeout) || 0;
+        node.bridge.send(pkt(0xF8, node.address, [0x05, chBit, ...make24(timeout)]));
+        return;
+      }
+      if (cmd === 'down') {
+        const timeout = parseInt(msg.payload.timeout) || 0;
+        node.bridge.send(pkt(0xF8, node.address, [0x06, chBit, ...make24(timeout)]));
+        return;
+      }
+      if (cmd === 'position') {
+        const pos = Math.max(0, Math.min(100, parseInt(msg.payload.position) || 0));
+        node.bridge.send(pkt(0xF8, node.address, [0x1C, chBit, pos]));
+        return;
+      }
+      if (cmd === 'lock') {
+        const duration = parseInt(msg.payload.duration) || 0xFFFFFF;
+        node.bridge.send(pkt(0xF8, node.address, [0x1A, chBit, ...make24(duration)]));
+        return;
+      }
+      if (cmd === 'unlock') {
+        node.bridge.send(pkt(0xF8, node.address, [0x1B, chBit]));
+        return;
+      }
+      if (cmd === 'forced_up') {
+        const duration = parseInt(msg.payload.duration) || 0xFFFFFF;
+        node.bridge.send(pkt(0xF8, node.address, [0x12, chBit, ...make24(duration)]));
+        return;
+      }
+      if (cmd === 'cancel_forced_up') {
+        node.bridge.send(pkt(0xF8, node.address, [0x13, chBit]));
+        return;
+      }
+      if (cmd === 'forced_down') {
+        const duration = parseInt(msg.payload.duration) || 0xFFFFFF;
+        node.bridge.send(pkt(0xF8, node.address, [0x14, chBit, ...make24(duration)]));
+        return;
+      }
+      if (cmd === 'cancel_forced_down') {
+        node.bridge.send(pkt(0xF8, node.address, [0x15, chBit]));
+        return;
+      }
+      if (cmd === 'inhibit') {
+        const duration = parseInt(msg.payload.duration) || 0xFFFFFF;
+        node.bridge.send(pkt(0xF8, node.address, [0x16, chBit, ...make24(duration)]));
+        return;
+      }
+      if (cmd === 'cancel_inhibit') {
+        node.bridge.send(pkt(0xF8, node.address, [0x17, chBit]));
+        return;
+      }
+      if (cmd === 'inhibit_preset_up') {
+        const duration = parseInt(msg.payload.duration) || 0xFFFFFF;
+        node.bridge.send(pkt(0xF8, node.address, [0x18, chBit, ...make24(duration)]));
+        return;
+      }
+      if (cmd === 'inhibit_preset_down') {
+        const duration = parseInt(msg.payload.duration) || 0xFFFFFF;
+        node.bridge.send(pkt(0xF8, node.address, [0x19, chBit, ...make24(duration)]));
+        return;
+      }
+      if (cmd === 'auto_mode') {
+        const mode = parseInt(msg.payload.mode) || 0; // 0=disabled, 1-3=mode
+        node.bridge.send(pkt(0xF8, node.address, [0xB3, chBit, mode]));
+        return;
+      }
+      if (cmd === 'get_name') {
+        node.bridge.send(pkt(0xF8, node.address, [0xEF, chBit]));
+        return;
+      }
+
+      node.warn('velbus-blind-s: unknown cmd: ' + cmd);
+    });
+
+    // ── Cleanup ───────────────────────────────────────────────────────────
+
+    node.on('close', function() {
+      node.bridge.deregister(node.address, onPacket);
+    });
+
+    setStatus('ready', 'grey', 'dot');
+  }
+
+  RED.nodes.registerType('velbus-blind-s', VelbusBlindSNode);
+};

package/nodes/velbus-bridge/velbus-bridge.html

@@ -0,0 +1,72 @@
+<script type="text/javascript">
+  RED.nodes.registerType('velbus-bridge', {
+    category: 'config',
+    defaults: {
+      name:     { value: 'Velbus Bridge' },
+      host:     { value: '127.0.0.1', required: true },
+      port:     { value: '6000',      required: true, validate: RED.validators.number() },
+      useTLS:   { value: false },
+      useAuth:  { value: false },
+      authKey:  { value: '' },
+      certPath: { value: '' },
+      keyPath:  { value: '' }
+    },
+    label: function() {
+      return this.name || (this.host + ':' + this.port);
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="velbus-bridge">
+  <div class="form-row">
+    <label for="node-config-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-config-input-name" placeholder="Velbus Bridge">
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-host"><i class="fa fa-server"></i> Host</label>
+    <input type="text" id="node-config-input-host" placeholder="127.0.0.1">
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-port"><i class="fa fa-plug"></i> Port</label>
+    <input type="number" id="node-config-input-port" placeholder="6000">
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-useTLS"><i class="fa fa-lock"></i> TLS</label>
+    <input type="checkbox" id="node-config-input-useTLS" style="display:inline-block;width:auto;vertical-align:top;">
+    &nbsp;Enable TLS (python-velbustcp)
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-useAuth"><i class="fa fa-key"></i> Auth</label>
+    <input type="checkbox" id="node-config-input-useAuth" style="display:inline-block;width:auto;vertical-align:top;">
+    &nbsp;Send auth key on connect
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-authKey"><i class="fa fa-key"></i> Auth Key</label>
+    <input type="password" id="node-config-input-authKey" placeholder="Auth key for python-velbustcp">
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-certPath"><i class="fa fa-certificate"></i> Cert path</label>
+    <input type="text" id="node-config-input-certPath" placeholder="/path/to/ca.crt">
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-keyPath"><i class="fa fa-file"></i> Key path</label>
+    <input type="text" id="node-config-input-keyPath" placeholder="/path/to/client.key">
+  </div>
+</script>
+
+<script type="text/html" data-help-name="velbus-bridge">
+    <p style="background:#fff3cd; border-left:4px solid #ffc107; padding:8px 12px; margin-bottom:12px; font-size:0.85em;">
+    <strong>&#9888; Testing status:</strong> This node was generated with Claude.ai and is in
+    need of extensive field testing before being deployed into a commercial project.
+    It is presented "as is" &mdash; any use beyond testing is entirely at your own risk and liability.
+    Constructive feedback is welcomed, accompanied by as many examples and debug captures as possible.
+    <a href="https://github.com/MDAR/node-red-contrib-velbus-2026/issues" target="_blank">File an issue on GitHub</a>.
+    </p>
+  <p>Configuration node. Manages a single persistent TCP connection to a Velbus gateway
+  (velbus-tcp snap on port 6000, or python-velbustcp on port 27015).</p>
+  <p>All <b>velbus-relay</b> nodes sharing this bridge use the same connection.
+  The bridge auto-reconnects if the connection is lost.</p>
+  <h3>TLS / Auth</h3>
+  <p>Enable <b>TLS</b> and <b>Auth</b> for python-velbustcp connections.
+  The auth key is sent as plain text immediately after the TCP handshake, followed by a newline.</p>
+</script>

package/nodes/velbus-bridge/velbus-bridge.js

@@ -0,0 +1,304 @@
+'use strict';
+
+const net = require('net');
+const tls = require('tls');
+const fs  = require('fs');
+const { splitPackets, parsePkt } = require('../../lib/velbus-utils');
+
+module.exports = function(RED) {
+
+  // ── Shared scan results store ───────────────────────────────────────────
+  // Keyed by bridge node ID → array of discovered module objects.
+  // Populated by velbus-scan node via bridge.storeScanResults().
+  // Served to config dialogs via RED.httpAdmin endpoint below.
+  // Persisted to a JSON file in the Node-RED user directory so that address
+  // dropdowns survive restarts and full deploys.
+  const path = require('path');
+  const _persistFile = path.join(RED.settings.userDir || '.', 'velbus-scan-results.json');
+  let _scanResults = {};
+  try {
+    _scanResults = JSON.parse(fs.readFileSync(_persistFile, 'utf8'));
+    RED.log.info('velbus-bridge: loaded persisted scan results (' +
+                 Object.keys(_scanResults).length + ' bridge(s))');
+  } catch (e) {
+    _scanResults = {}; // No file yet, or unreadable — start empty
+  }
+
+  function _persistScanResults() {
+    fs.writeFile(_persistFile, JSON.stringify(_scanResults, null, 2), (err) => {
+      if (err) RED.log.warn('velbus-bridge: could not persist scan results — ' + err.message);
+    });
+  }
+
+  // ── HTTP Admin endpoint ─────────────────────────────────────────────────
+  // GET /velbus/scan-results?bridge=<nodeId>
+  // Returns the most recent scan results for a given bridge node.
+  // Called by config dialog dropdowns to populate address lists.
+  RED.httpAdmin.get('/velbus/scan-results', RED.auth.needsPermission(''), function(req, res) {
+    const bridgeId = req.query.bridge;
+    if (!bridgeId) {
+      return res.json({ modules: [], error: 'No bridge ID specified' });
+    }
+    const results = _scanResults[bridgeId] || [];
+    res.json({ modules: results, count: results.length });
+  });
+
+  // ── Bridge node constructor ─────────────────────────────────────────────
+
+  function VelbusBridgeNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    // Config
+    node.host     = config.host     || '127.0.0.1';
+    node.port     = parseInt(config.port) || 6000;
+    node.useTLS   = config.useTLS   === true;
+    node.useAuth  = config.useAuth  === true;
+    node.authKey  = config.authKey  || '';
+    node.certPath = config.certPath || '';
+    node.keyPath  = config.keyPath  || '';
+
+    // Registered interpreter nodes: Map<address, Set<handlerFn>>
+    node._listeners  = new Map();
+    node._subaddrMap = new Map();
+
+    // Rebuild subaddress routing from persisted scan results, so subaddress
+    // frames (e.g. GPO-20 thermostat events from 0x34) route to primary-address
+    // listeners without requiring a fresh scan after every restart or deploy.
+    for (const m of (_scanResults[node.id] || [])) {
+      if (m.subaddresses && m.address) {
+        const primary = parseInt(m.address, 16);
+        for (const s of m.subaddresses) {
+          const sub = parseInt(s, 16);
+          if (sub >= 0x01 && sub <= 0xFE) node._subaddrMap.set(sub, primary);
+        }
+      }
+    }
+    if (node._subaddrMap.size) {
+      node.log('velbus-bridge: restored ' + node._subaddrMap.size +
+               ' subaddress mapping(s) from persisted scan results');
+    }
+
+    // Scan lock
+    node._scanLocked = false;
+    node._scanQueue  = [];
+
+    // TCP state
+    node._socket         = null;
+    node._remainder      = Buffer.alloc(0);
+    node._connected      = false;
+    node._closing        = false;
+    node._reconnectTimer = null;
+
+    // ── Scan results store API ────────────────────────────────────────────
+
+    node.storeScanResults = function(modules) {
+      _scanResults[node.id] = modules;
+      _persistScanResults();
+      node.log('velbus-bridge: stored ' + modules.length + ' scan results for address dropdown');
+    };
+
+    node.getScanResults = function() {
+      return _scanResults[node.id] || [];
+    };
+
+    // ── Scan lock API ─────────────────────────────────────────────────────
+
+    node.lockScan = function() {
+      node._scanLocked = true;
+      node._scanQueue  = [];
+      node.log('velbus-bridge: scan lock engaged — interpreter startup queued');
+    };
+
+    node.unlockScan = function() {
+      node._scanLocked = false;
+      node.log('velbus-bridge: scan lock released — flushing ' +
+        node._scanQueue.length + ' queued startup packet(s)');
+      let delay = 500;
+      for (const item of node._scanQueue) {
+        setTimeout(() => {
+          if (!node._closing) node.send(item.buf);
+        }, delay);
+        delay += 1000;
+      }
+      node._scanQueue = [];
+    };
+
+    // ── Send packet ───────────────────────────────────────────────────────
+
+    node.send = function(buf, startup) {
+      if (node._scanLocked && startup) {
+        node._scanQueue.push({ buf: Buffer.from(buf) });
+        return;
+      }
+      if (node._socket && node._connected) {
+        node._socket.write(buf);
+      } else {
+        node.warn('velbus-bridge: not connected, packet dropped');
+      }
+    };
+
+    // ── Connection state (public accessor) ────────────────────────────────
+
+    node.isConnected = function() {
+      return !!node._connected;
+    };
+
+    // ── Listener registration ─────────────────────────────────────────────
+
+    node.register = function(addr, handler) {
+      const key = addr === 'all' ? 'all' : Number(addr);
+      if (!node._listeners.has(key)) node._listeners.set(key, new Set());
+      node._listeners.get(key).add(handler);
+    };
+
+    node.deregister = function(addr, handler) {
+      const key = addr === 'all' ? 'all' : Number(addr);
+      if (node._listeners.has(key)) {
+        node._listeners.get(key).delete(handler);
+        for (const [sub, primary] of node._subaddrMap.entries()) {
+          if (primary === key) node._subaddrMap.delete(sub);
+        }
+      }
+    };
+
+    // ── 0xB0 subtype handler ──────────────────────────────────────────────
+
+    function handleSubtype(pktBuf) {
+      const p = parsePkt(pktBuf);
+      if (!p || p.cmd !== 0xB0 || p.body.length < 8) return;
+
+      const primaryAddr = p.addr;
+      const subAddrs = [p.body[4], p.body[5], p.body[6], p.body[7]];
+
+      for (const [sub, primary] of node._subaddrMap.entries()) {
+        if (primary === primaryAddr) node._subaddrMap.delete(sub);
+      }
+
+      let registered = 0;
+      for (const sub of subAddrs) {
+        if (sub !== 0xFF && sub >= 0x01 && sub <= 0xFE) {
+          node._subaddrMap.set(sub, primaryAddr);
+          registered++;
+        }
+      }
+
+      if (registered > 0) {
+        node.log('velbus-bridge: 0x' + primaryAddr.toString(16).toUpperCase() +
+          ' subaddresses: ' + subAddrs
+            .filter(s => s !== 0xFF)
+            .map(s => '0x' + s.toString(16).toUpperCase())
+            .join(', '));
+      }
+    }
+
+    // ── Packet dispatch ───────────────────────────────────────────────────
+
+    function dispatch(pktBuf) {
+      if (!Buffer.isBuffer(pktBuf) || pktBuf.length < 6) return;
+
+      const rawAddr = pktBuf[2];
+      const cmd     = pktBuf.length >= 5 ? pktBuf[4] : null;
+
+      if (cmd === 0xB0) handleSubtype(pktBuf);
+
+      const deliverAddr = node._subaddrMap.has(rawAddr)
+        ? node._subaddrMap.get(rawAddr)
+        : rawAddr;
+
+      const addrListeners = node._listeners.get(deliverAddr);
+      if (addrListeners) {
+        for (const h of addrListeners) {
+          try { h(pktBuf); } catch(e) { node.error('velbus-bridge dispatch error: ' + e.message); }
+        }
+      }
+
+      const allListeners = node._listeners.get('all');
+      if (allListeners) {
+        for (const h of allListeners) {
+          try { h(pktBuf); } catch(e) { node.error('velbus-bridge dispatch error: ' + e.message); }
+        }
+      }
+    }
+
+    // ── TCP connection ────────────────────────────────────────────────────
+
+    function connect() {
+      if (node._closing) return;
+
+      function onConnected() {
+        node._connected = true;
+        node._remainder = Buffer.alloc(0);
+        node.log(`velbus-bridge: connected to ${node.host}:${node.port}` +
+                 (node.useTLS ? ' (TLS)' : ''));
+        if (node.useAuth && node.authKey) sock.write(node.authKey + '\n');
+      }
+
+      let sock;
+      if (node.useTLS) {
+        const tlsOpts = { host: node.host, port: node.port };
+        if (node.certPath) {
+          // CA supplied: verify the chain but skip hostname check, since
+          // velbus-tcp is almost always reached by bare IP address.
+          tlsOpts.ca = fs.readFileSync(node.certPath);
+          tlsOpts.checkServerIdentity = () => undefined;
+        } else {
+          // No CA supplied: accept the velbus-tcp snap's self-signed cert.
+          tlsOpts.rejectUnauthorized = false;
+        }
+        if (node.keyPath) tlsOpts.key = fs.readFileSync(node.keyPath);
+        sock = tls.connect(tlsOpts);
+        // TLS sockets emit 'secureConnect' when the handshake completes.
+        // They never emit 'connect' — that fires on the wrapped raw socket.
+        sock.on('secureConnect', onConnected);
+      } else {
+        sock = net.createConnection({ host: node.host, port: node.port });
+        sock.on('connect', onConnected);
+      }
+
+      node._socket = sock;
+      sock.setNoDelay(true);
+
+      sock.on('data', (data) => {
+        const combined = Buffer.concat([node._remainder, data]);
+        const { packets, remainder } = splitPackets(combined);
+        node._remainder = remainder;
+        for (const p of packets) dispatch(p);
+      });
+
+      sock.on('error', (err) => {
+        let msg = `velbus-bridge: socket error — ${err.message}`;
+        if (node.useTLS && /certificate|handshake|SSL|TLS/i.test(err.message)) {
+          msg += ' (TLS handshake failed — check the auth key and that the ' +
+                 'port is the TLS port; leave Cert path empty to accept ' +
+                 'velbus-tcp\'s self-signed certificate)';
+        }
+        node.warn(msg);
+      });
+
+      sock.on('close', () => {
+        node._connected = false;
+        node._socket = null;
+        if (!node._closing) {
+          node.warn('velbus-bridge: connection lost, reconnecting in 5s');
+          node._reconnectTimer = setTimeout(connect, 5000);
+        }
+      });
+    }
+
+    // ── Lifecycle ─────────────────────────────────────────────────────────
+
+    connect();
+
+    node.on('close', (done) => {
+      node._closing = true;
+      if (node._reconnectTimer) clearTimeout(node._reconnectTimer);
+      if (node._socket) { node._socket.destroy(); node._socket = null; }
+      // Scan results are intentionally kept — 'close' fires on every full
+      // deploy and restart, and dropdowns must survive both.
+      done();
+    });
+  }
+
+  RED.nodes.registerType('velbus-bridge', VelbusBridgeNode);
+};