@tier0/opcua-client 0.4.0 → 0.5.0

package/nodes/subscribe.html

@@ -2,12 +2,41 @@
   .opcua-advanced { margin: 8px 0 12px; }
   .opcua-advanced summary { cursor: pointer; font-weight: 600; padding: 6px 0; }
   .opcua-standard-note { margin: 0 0 10px 105px; color: var(--red-ui-form-text-color, #666); font-size: 0.9em; }
+  .opcua-point-editor { box-sizing: border-box; display: inline-block; vertical-align: top; width: calc(100% - 110px); }
+  .opcua-point-toolbar { display: flex; gap: 6px; margin-bottom: 8px; }
+  .opcua-point-add { display: flex; gap: 6px; margin-bottom: 8px; }
+  .opcua-point-add input { flex: 1; min-width: 0; }
+  .opcua-point-list { border: 1px solid var(--red-ui-form-input-border-color, #ccc); border-radius: 2px; box-sizing: border-box; height: 180px; list-style: none; margin: 0 !important; overflow: auto; padding: 0 !important; width: 100%; }
+  .opcua-point-list li { align-items: center; border-bottom: 1px solid var(--red-ui-secondary-border-color, #eee); display: flex; gap: 8px; min-height: 34px; padding: 4px 8px; }
+  .opcua-point-list li:last-child { border-bottom: 0; }
+  .opcua-point-list .opcua-point-text { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .opcua-point-list .opcua-point-empty { color: var(--red-ui-form-placeholder-color, #888); justify-content: center; }
+  .opcua-point-list .opcua-point-remove { border: 0; color: var(--red-ui-text-color, #555); flex: 0 0 auto; }
+  .opcua-point-status { color: var(--red-ui-form-text-color, #666); font-size: 0.9em; margin-top: 5px; }
 </style>
 <script type="text/html" data-template-name="tier0-opcua-subscribe">
   <div class="form-row"><label for="node-input-connection">Connection</label><input type="text" id="node-input-connection"></div>
-  <div class="form-row"><label for="node-input-nodeId">NodeId</label><input type="text" id="node-input-nodeId" placeholder="Optional when input supplies points"></div>
+  <input type="hidden" id="node-input-nodeId">
+  <input type="hidden" id="node-input-pointList">
+  <input type="hidden" id="node-input-pointListFileName">
+  <input type="file" id="node-input-pointFile" accept=".json,.csv,application/json,text/csv" style="display:none">
+  <div class="form-row">
+    <label>Points</label>
+    <div class="opcua-point-editor">
+      <div class="opcua-point-toolbar">
+        <button type="button" class="red-ui-button" id="node-input-importPointList"><i class="fa fa-upload"></i> Import</button>
+        <button type="button" class="red-ui-button" id="node-input-clearPointList"><i class="fa fa-trash"></i> Clear all</button>
+      </div>
+      <div class="opcua-point-add">
+        <input type="text" id="node-input-newPointNodeId" placeholder="NodeId, for example ns=2;s=Machine.Speed">
+        <button type="button" class="red-ui-button" id="node-input-addPoint"><i class="fa fa-plus"></i> Add</button>
+      </div>
+      <ol class="opcua-point-list" id="node-input-pointListItems"></ol>
+      <div class="opcua-point-status" id="node-input-pointListStatus">0 points</div>
+    </div>
+  </div>
   <div class="form-row"><label for="node-input-samplingInterval">Sampling (ms)</label><input type="number" id="node-input-samplingInterval"></div>
-  <div class="opcua-standard-note">Standard mode keeps the latest pending value per point, shards large point sets, batches changes, and automatically restores them after reconnect.</div>
+  <div class="opcua-standard-note">Saved points start automatically after deploy. Repeated identical point lists are reconciled without rebuilding server subscriptions.</div>
   <details class="opcua-advanced">
     <summary>Advanced subscription and queue settings</summary>
     <div class="form-row"><label for="node-input-publishingInterval">Publishing interval</label><input type="number" id="node-input-publishingInterval"></div>
@@ -33,7 +62,7 @@
     <h3>订阅（Subscribe）</h3>
     <p>创建 OPC UA Subscription 和 MonitoredItems，由服务器在值变化时推送通知；它不是客户端定时 Read。大量点位会按照服务器限制自动拆分到多个 Subscription。</p>
     <h4>输入与命令</h4>
-    <p>点表可来自数组、JSON、CSV 或 Browse 输出。通过 <code>msg.opcua.command</code> 使用 <code>replace</code>、<code>add</code>、<code>remove</code>、<code>clear</code> 动态管理点位。</p>
+    <p>可直接保存或导入 JSON/CSV 点表；部署后自动建立订阅。点表也可来自消息或 Browse 输出，通过 <code>msg.opcua.command</code> 使用 <code>replace</code>、<code>add</code>、<code>remove</code>、<code>clear</code> 动态管理点位。重复的相同点表不会重建 Subscription。</p>
     <h4>时间与队列</h4>
     <ul>
       <li><b>Sampling</b>：服务器检查 MonitoredItem 的请求间隔。</li>
@@ -55,7 +84,7 @@
     <h3>Subscribe</h3>
     <p>Creates one or more OPC UA subscriptions and MonitoredItems so the server sends data-change notifications. It is not a periodic client Read. Large point sets are automatically sharded across Subscriptions according to server limits.</p>
     <h4>Input and commands</h4>
-    <p>Point lists may come from arrays, JSON, CSV, or Browse output. Use <code>replace</code>, <code>add</code>, <code>remove</code>, or <code>clear</code> in <code>msg.opcua.command</code> to manage points dynamically.</p>
+    <p>Save or import a JSON/CSV point list to start automatically after deploy. Point lists may also come from messages or Browse output. Use <code>replace</code>, <code>add</code>, <code>remove</code>, or <code>clear</code> in <code>msg.opcua.command</code> to manage points dynamically. Repeating an unchanged list does not rebuild the server Subscription.</p>
     <h4>Timing and queues</h4>
     <ul>
       <li><b>Sampling</b>: Requested interval at which the server checks a MonitoredItem.</li>
@@ -77,7 +106,8 @@
   RED.nodes.registerType('tier0-opcua-subscribe', {
     category: 'OPC UA', color: '#c7e9f1', inputs: 1, outputs: 1, icon: 'bridge.png',
     defaults: {
-      connection: { value: '', type: 'tier0-opcua-connection', required: true }, nodeId: { value: '' },
+      connection: { value: '', type: 'tier0-opcua-connection', required: true },
+      nodeId: { value: '' }, pointList: { value: '' }, pointListFileName: { value: '' },
       publishingInterval: { value: 1000, validate: RED.validators.number() }, samplingInterval: { value: 1000, validate: RED.validators.number() },
       queueSize: { value: 1, validate: RED.validators.number() }, discardOldest: { value: true },
       deadbandType: { value: 'none' }, deadbandValue: { value: 0, validate: RED.validators.number() },
@@ -91,6 +121,134 @@
       lifetimeCount: { value: 120 }, maxKeepAliveCount: { value: 10 }, maxNotificationsPerPublish: { value: 0 },
       reconnectInterval: { value: 5000 }, name: { value: '' }
     },
+    oneditprepare: function () {
+      const points = new Map();
+
+      const csvLine = (line) => {
+        const fields = [];
+        let value = '';
+        let quoted = false;
+        for (let index = 0; index < line.length; index += 1) {
+          const character = line[index];
+          if (character === '"') {
+            if (quoted && line[index + 1] === '"') { value += '"'; index += 1; }
+            else quoted = !quoted;
+          } else if (character === ',' && !quoted) {
+            fields.push(value.trim()); value = '';
+          } else value += character;
+        }
+        fields.push(value.trim());
+        return fields;
+      };
+
+      const parse = (content) => {
+        const text = String(content || '').replace(/^\uFEFF/, '').trim();
+        if (!text) return [];
+        if (text.startsWith('[') || text.startsWith('{')) {
+          const parsed = JSON.parse(text);
+          return Array.isArray(parsed) ? parsed : (Array.isArray(parsed.items) ? parsed.items : [parsed]);
+        }
+        const lines = text.split(/\r?\n/).filter((line) => line.trim() && !line.trimStart().startsWith('#'));
+        if (!lines.length) return [];
+        const headers = csvLine(lines.shift());
+        if (!headers.includes('nodeId')) throw new Error('CSV header must contain nodeId');
+        return lines.map((line) => {
+          const values = csvLine(line);
+          return Object.fromEntries(headers.map((header, index) => [header, values[index] || '']));
+        });
+      };
+
+      const normalize = (item) => {
+        const source = typeof item === 'string' ? { nodeId: item } : { ...(item || {}) };
+        source.nodeId = String(source.nodeId || source.topic || '').trim();
+        if (!source.nodeId) throw new Error('Point is missing nodeId');
+        return source;
+      };
+
+      const persist = () => {
+        const items = [...points.values()];
+        $('#node-input-pointList').val(items.length ? JSON.stringify(items) : '');
+        if (items.length) $('#node-input-nodeId').val('');
+        $('#node-input-pointListStatus').text(`${items.length} point${items.length === 1 ? '' : 's'}`);
+      };
+
+      const render = () => {
+        const list = document.getElementById('node-input-pointListItems');
+        list.textContent = '';
+        if (!points.size) {
+          const empty = document.createElement('li');
+          empty.className = 'opcua-point-empty';
+          empty.textContent = 'No saved points. Add a NodeId, import a file, or supply points by message.';
+          list.appendChild(empty);
+        } else {
+          const fragment = document.createDocumentFragment();
+          points.forEach((point, nodeId) => {
+            const row = document.createElement('li');
+            const text = document.createElement('span');
+            text.className = 'opcua-point-text';
+            text.textContent = point.alias ? `${point.alias} — ${nodeId}` : nodeId;
+            text.title = text.textContent;
+            const remove = document.createElement('button');
+            remove.type = 'button';
+            remove.className = 'red-ui-button opcua-point-remove';
+            remove.title = `Remove ${nodeId}`;
+            remove.innerHTML = '<i class="fa fa-times"></i>';
+            remove.addEventListener('click', () => { points.delete(nodeId); render(); });
+            row.append(text, remove);
+            fragment.appendChild(row);
+          });
+          list.appendChild(fragment);
+        }
+        persist();
+      };
+
+      const merge = (items) => {
+        items.forEach((item) => { const point = normalize(item); points.set(point.nodeId, point); });
+        render();
+      };
+
+      try {
+        const stored = $('#node-input-pointList').val();
+        if (stored) merge(parse(stored));
+        else if ($('#node-input-nodeId').val()) merge([{ nodeId: $('#node-input-nodeId').val() }]);
+        else render();
+      } catch (error) {
+        RED.notify(`Cannot load point list: ${error.message}`, 'error');
+        render();
+      }
+
+      $('#node-input-addPoint').on('click', () => {
+        try {
+          merge([{ nodeId: $('#node-input-newPointNodeId').val() }]);
+          $('#node-input-newPointNodeId').val('').focus();
+        } catch (error) { RED.notify(error.message, 'error'); }
+      });
+      $('#node-input-newPointNodeId').on('keydown', function (event) {
+        if (event.key === 'Enter') { event.preventDefault(); $('#node-input-addPoint').click(); }
+      });
+      $('#node-input-importPointList').on('click', () => $('#node-input-pointFile').click());
+      $('#node-input-pointFile').on('change', function () {
+        const file = this.files && this.files[0];
+        if (!file) return;
+        const reader = new FileReader();
+        reader.onload = () => {
+          try {
+            const imported = parse(reader.result);
+            merge(imported);
+            $('#node-input-pointListFileName').val(file.name);
+            RED.notify(`${imported.length} point(s) imported`, 'success');
+          } catch (error) { RED.notify(`Import failed: ${error.message}`, 'error'); }
+          $('#node-input-pointFile').val('');
+        };
+        reader.readAsText(file);
+      });
+      $('#node-input-clearPointList').on('click', () => {
+        points.clear();
+        $('#node-input-nodeId').val('');
+        $('#node-input-pointListFileName').val('');
+        render();
+      });
+    },
     label: function () { return this.name || 'tier0-opcua-subscribe'; }
   });
 </script>

package/nodes/subscribe.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { messagePoints } = require('../lib/points');
+const { looksLikePointList, messagePoints } = require('../lib/points');
 
 const NOTIFICATION_CONFIG_FIELDS = new Set([
   'nodeId',
@@ -55,6 +55,43 @@ function positiveInteger(value, fallback) {
   return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;
 }
 
+function monitoringSettings(point, config) {
+  return {
+    samplingInterval: Number(point.samplingInterval) || Number(config.samplingInterval) || 1000,
+    queueSize: positiveInteger(point.queueSize, positiveInteger(config.queueSize, 1)),
+    discardOldest: point.discardOldest !== false,
+    deadbandType: point.deadbandType || config.deadbandType || 'none',
+    deadbandValue: Number(point.deadbandValue ?? config.deadbandValue) || 0,
+  };
+}
+
+function sameMonitoringSettings(left, right, config) {
+  const leftSettings = monitoringSettings(left, config);
+  const rightSettings = monitoringSettings(right, config);
+  return Object.keys(leftSettings).every(
+    (key) => leftSettings[key] === rightSettings[key]
+  );
+}
+
+function numericRange(items, field) {
+  let count = 0;
+  let minimum = Infinity;
+  let maximum = -Infinity;
+  for (const item of items) {
+    if (item[field] == null) continue;
+    const value = Number(item[field]);
+    if (!Number.isFinite(value)) continue;
+    count += 1;
+    minimum = Math.min(minimum, value);
+    maximum = Math.max(maximum, value);
+  }
+  return {
+    count,
+    minimum: count ? minimum : null,
+    maximum: count ? maximum : null,
+  };
+}
+
 module.exports = function registerSubscribeNode(RED) {
   function OpcUaSubscribeNode(config) {
     RED.nodes.createNode(this, config);
@@ -63,6 +100,7 @@ module.exports = function registerSubscribeNode(RED) {
     node.subscriptions = new Map();
     node.desired = new Map();
     node.monitored = new Map();
+    node.failed = new Map();
     node.subscriptionDiagnostics = new Map();
     node.pendingChanges = [];
     node.flushTimer = null;
@@ -73,6 +111,9 @@ module.exports = function registerSubscribeNode(RED) {
     node.closing = false;
     node.lastDropped = 0;
     node.lastStatusAt = 0;
+    const consumer = node.connection?.registerConsumer?.('subscribe', {
+      nodeId: config.id, name: config.name,
+    });
 
     const batchSize = positiveInteger(config.batchSize, 500);
     const callbackBatchSize = positiveInteger(config.callbackBatchSize, 500);
@@ -253,6 +294,9 @@ module.exports = function registerSubscribeNode(RED) {
         id: null,
         monitored: new Map(),
         limit: subscriptionCapacity(),
+        revisedPublishingInterval: null,
+        revisedLifetimeCount: null,
+        revisedMaxKeepAliveCount: null,
       };
       const result = await node.connection.client.createSubscription({
         publishingInterval: Number(config.publishingInterval) || 1000,
@@ -265,6 +309,9 @@ module.exports = function registerSubscribeNode(RED) {
         overflowPolicy: config.overflowPolicy || 'drop-oldest',
       }, (batch) => onNativeBatch(record, batch));
       record.id = result.subscriptionId;
+      record.revisedPublishingInterval = result.revisedPublishingInterval ?? null;
+      record.revisedLifetimeCount = result.revisedLifetimeCount ?? null;
+      record.revisedMaxKeepAliveCount = result.revisedMaxKeepAliveCount ?? null;
       node.subscriptions.set(record.id, record);
       return record;
     }
@@ -291,6 +338,8 @@ module.exports = function registerSubscribeNode(RED) {
           subscriptionId: record.id,
           monitoredItemId: result.monitoredItemId,
           clientHandle: result.clientHandle,
+          revisedSamplingInterval: result.revisedSamplingInterval ?? null,
+          revisedQueueSize: result.revisedQueueSize ?? null,
         };
         record.monitored.set(result.nodeId, monitored);
         node.monitored.set(result.nodeId, monitored);
@@ -343,10 +392,10 @@ module.exports = function registerSubscribeNode(RED) {
       return failures;
     }
 
-    async function removeUndesiredPoints() {
+    async function removeMonitoredPoints(nodeIds) {
       const grouped = new Map();
       for (const [nodeId, monitored] of node.monitored) {
-        if (node.desired.has(nodeId)) continue;
+        if (!nodeIds.has(nodeId)) continue;
         if (!grouped.has(monitored.subscriptionId)) grouped.set(monitored.subscriptionId, []);
         grouped.get(monitored.subscriptionId).push({ nodeId, ...monitored });
       }
@@ -367,6 +416,13 @@ module.exports = function registerSubscribeNode(RED) {
       }
     }
 
+    async function removeUndesiredPoints() {
+      const nodeIds = new Set(
+        [...node.monitored.keys()].filter((nodeId) => !node.desired.has(nodeId))
+      );
+      await removeMonitoredPoints(nodeIds);
+    }
+
     async function pruneEmptySubscriptions() {
       const empty = [...node.subscriptions.values()].filter(
         (record) => record.monitored.size === 0
@@ -380,7 +436,10 @@ module.exports = function registerSubscribeNode(RED) {
     }
 
     async function clearSubscriptions(keepDesired = false, ignoreErrors = false) {
-      if (!keepDesired) node.desired.clear();
+      if (!keepDesired) {
+        node.desired.clear();
+        node.failed.clear();
+      }
       discardPendingChanges();
       const records = [...node.subscriptions.values()];
       node.subscriptions.clear();
@@ -403,22 +462,49 @@ module.exports = function registerSubscribeNode(RED) {
       return true;
     }
 
-    function statusPayload(command, failed = 0) {
+    function failurePayload() {
+      const failures = [...node.failed.values()];
+      return {
+        failed: failures.length,
+        failures: failures.slice(0, 100),
+        failuresTruncated: failures.length > 100,
+      };
+    }
+
+    function statusPayload(command) {
       const ids = subscriptionIds();
+      const monitoredValues = [...node.monitored.values()];
+      const revisedSampling = numericRange(monitoredValues, 'revisedSamplingInterval');
+      const revisedQueues = numericRange(monitoredValues, 'revisedQueueSize');
       return {
         command,
         desired: node.desired.size,
         monitored: node.monitored.size,
-        failed,
+        ...failurePayload(),
         subscriptionCount: ids.length,
         subscriptionId: ids[0] ?? null,
         subscriptionIds: ids,
+        revisions: [...node.subscriptions.values()].map((record) => ({
+          subscriptionId: record.id,
+          publishingInterval: record.revisedPublishingInterval,
+          lifetimeCount: record.revisedLifetimeCount,
+          maxKeepAliveCount: record.revisedMaxKeepAliveCount,
+        })),
+        monitoredRevisions: {
+          count: Math.max(revisedSampling.count, revisedQueues.count),
+          samplingIntervalMin: revisedSampling.minimum,
+          samplingIntervalMax: revisedSampling.maximum,
+          queueSizeMin: revisedQueues.minimum,
+          queueSizeMax: revisedQueues.maximum,
+        },
         connectionGovernance: node.connection?.getConnectionGovernance?.(),
+        connectionUsage: node.connection?.getConnectionUsage?.(),
       };
     }
 
     async function reconcileSubscriptions(reason = 'state') {
       if (node.closing) return;
+      consumer?.markUsed('subscribe-reconcile');
       if (!node.desired.size) {
         if (node.subscriptions.size) await clearSubscriptions(true);
         return;
@@ -439,15 +525,21 @@ module.exports = function registerSubscribeNode(RED) {
         (point) => !node.monitored.has(point.nodeId)
       );
       const failures = await addDesiredPoints(additions);
-      await pruneEmptySubscriptions();
-      if (failures.length) {
-        throw new Error(`${failures.length} monitored item(s) failed to reconcile`);
+      for (const point of additions) node.failed.delete(point.nodeId);
+      for (const failure of failures) {
+        node.failed.set(failure.nodeId, {
+          nodeId: failure.nodeId,
+          statusCode: failure.statusCode || 'BadUnexpectedError',
+        });
       }
+      await pruneEmptySubscriptions();
 
       node.reconcileAttempt = 0;
       node.status({
-        fill: 'green', shape: 'dot',
-        text: `${node.monitored.size} monitored / ${node.subscriptions.size} sub`,
+        fill: failures.length ? 'yellow' : 'green',
+        shape: failures.length ? 'ring' : 'dot',
+        text: `${node.monitored.size} monitored / ${node.subscriptions.size} sub` +
+          (failures.length ? ` / ${failures.length} failed` : ''),
       });
       if (reason !== 'command') {
         node.send({
@@ -462,12 +554,25 @@ module.exports = function registerSubscribeNode(RED) {
           },
         });
       }
+      return { rebuilt, failures };
     }
 
     async function replacePoints(points) {
-      node.desired = new Map(points.map((point) => [point.nodeId, point]));
-      await clearSubscriptions(true);
-      await reconcileSubscriptions('command');
+      const nextDesired = new Map(points.map((point) => [point.nodeId, point]));
+      const changed = new Set();
+      for (const [nodeId, monitored] of node.monitored) {
+        const previous = node.desired.get(nodeId);
+        const next = nextDesired.get(nodeId);
+        if (!next || !previous || !sameMonitoringSettings(previous, next, config)) {
+          changed.add(nodeId);
+        }
+      }
+      node.desired = nextDesired;
+      for (const nodeId of [...node.failed.keys()]) {
+        if (!node.desired.has(nodeId)) node.failed.delete(nodeId);
+      }
+      await removeMonitoredPoints(changed);
+      return reconcileSubscriptions('command');
     }
 
     function runSerialized(task) {
@@ -517,28 +622,49 @@ module.exports = function registerSubscribeNode(RED) {
       if (!node.connection) return done(new Error('OPC UA connection not configured'));
       try {
         const command = msg.opcua?.command || 'replace';
-        const points = command === 'clear' ? [] : messagePoints(msg, config.nodeId, {
+        const dynamicNodeId = msg.nodeId || msg.topic;
+        const configuredPayload = !looksLikePointList(msg.payload) && !Array.isArray(msg.items) &&
+          !dynamicNodeId ? config.pointList : '';
+        const staticNodeId = dynamicNodeId ? '' : config.nodeId;
+        const points = command === 'clear' ? [] : messagePoints(msg, staticNodeId, {
           samplingInterval: Number(config.samplingInterval) || 1000,
           queueSize: Number(config.queueSize) || 10,
           discardOldest: config.discardOldest !== false,
+        }, {
+          configuredPayload,
+          format: 'auto',
         });
 
         node.status({ fill: 'blue', shape: 'dot', text: `${command} ${points.length}` });
         await runSerialized(async () => {
           if (command === 'replace') await replacePoints(points);
           else if (command === 'add') {
-            points.forEach((point) => node.desired.set(point.nodeId, point));
+            const changed = new Set();
+            points.forEach((point) => {
+              const previous = node.desired.get(point.nodeId);
+              if (previous && !sameMonitoringSettings(previous, point, config)) {
+                changed.add(point.nodeId);
+              }
+              node.desired.set(point.nodeId, point);
+              node.failed.delete(point.nodeId);
+            });
+            await removeMonitoredPoints(changed);
             await reconcileSubscriptions('command');
           } else if (command === 'remove') {
-            points.forEach((point) => node.desired.delete(point.nodeId));
+            points.forEach((point) => {
+              node.desired.delete(point.nodeId);
+              node.failed.delete(point.nodeId);
+            });
             await reconcileSubscriptions('command');
           } else if (command === 'clear') await clearSubscriptions();
           else throw new Error(`Unsupported subscription command: ${command}`);
         });
 
+        const failed = node.failed.size;
         node.status({
-          fill: 'green', shape: 'dot',
-          text: `${node.monitored.size} monitored / ${node.subscriptions.size} sub`,
+          fill: failed ? 'yellow' : 'green', shape: failed ? 'ring' : 'dot',
+          text: `${node.monitored.size} monitored / ${node.subscriptions.size} sub` +
+            (failed ? ` / ${failed} failed` : ''),
         });
         send({
           ...msg,
@@ -552,20 +678,63 @@ module.exports = function registerSubscribeNode(RED) {
       }
     });
 
-    node.on('close', async (done) => {
+    async function cleanupSubscription() {
       node.closing = true;
       if (node.reconnectTimer) clearTimeout(node.reconnectTimer);
+      node.reconnectTimer = null;
       discardPendingChanges();
       node.connection?.client.off('fault', onFault);
       node.connection?.client.off('state', onState);
       node.desired.clear();
+      node.failed.clear();
+      consumer?.release();
+      await runSerialized(() => clearSubscriptions());
+    }
+
+    const runCleanup = node.connection?.registerDependentCleanup?.(cleanupSubscription) ||
+      cleanupSubscription;
+
+    node.on('close', async (done) => {
       try {
-        await runSerialized(() => clearSubscriptions());
+        await runCleanup();
       } catch (error) {
         node.warn(`OPC UA subscription cleanup failed: ${error.message}`);
       }
       done();
     });
+
+    const configuredPoints = String(config.pointList || '').trim() ||
+      String(config.nodeId || '').trim();
+    if (configuredPoints) {
+      setImmediate(() => {
+        if (node.closing) return;
+        let points;
+        try {
+          points = messagePoints({}, config.nodeId, {
+            samplingInterval: Number(config.samplingInterval) || 1000,
+            queueSize: Number(config.queueSize) || 10,
+            discardOldest: config.discardOldest !== false,
+          }, {
+            configuredPayload: config.pointList,
+            format: 'auto',
+          });
+        } catch (error) {
+          node.status({ fill: 'red', shape: 'ring', text: error.message });
+          node.warn(`OPC UA saved subscription point list is invalid: ${error.message}`);
+          return;
+        }
+        void runSerialized(() => replacePoints(points)).then(() => {
+          node.send({
+            payload: statusPayload('startup'),
+            opcua: { operation: 'subscription-status', startup: true },
+          });
+        }).catch((error) => {
+          node.status({ fill: 'yellow', shape: 'ring', text: 'waiting to subscribe' });
+          node.warn(`OPC UA startup subscription failed: ${error.message}`);
+          scheduleReconnect('startup');
+        });
+      });
+    }
   }
 
   RED.nodes.registerType('tier0-opcua-subscribe', OpcUaSubscribeNode);

package/nodes/write.html

@@ -54,6 +54,7 @@
       <li>单点：NodeId 来自节点配置、<code>msg.nodeId</code> 或 <code>msg.topic</code>，写入值来自 <code>msg.payload</code>。</li>
       <li>批量：通过编辑器、JSON 或 CSV 提供 <code>nodeId</code>、<code>value</code> 和可选 <code>dataType</code>。</li>
       <li>CSV 必须包含 <code>nodeId</code> 和 <code>value</code>；未指定类型时使用节点默认类型。</li>
+      <li>Int64/UInt64 建议使用十进制字符串；超范围、小数和不安全的 Number 会在发送前被拒绝。</li>
       <li><code>indexRange</code> 可部分写入数组或矩阵。</li>
     </ul>
     <h4>输出</h4>
@@ -68,6 +69,7 @@
       <li>Single point: NodeId comes from the node setting, <code>msg.nodeId</code>, or <code>msg.topic</code>; the value comes from <code>msg.payload</code>.</li>
       <li>Batch: Supply <code>nodeId</code>, <code>value</code>, and optional <code>dataType</code> through the editor, JSON, or CSV.</li>
       <li>CSV requires <code>nodeId</code> and <code>value</code>. The node default type is used when <code>dataType</code> is omitted.</li>
+      <li>Use decimal strings for Int64/UInt64. Out-of-range, fractional, and unsafe Number values are rejected before transmission.</li>
       <li>Use <code>indexRange</code> for partial array or matrix writes.</li>
     </ul>
     <h4>Output</h4>

package/nodes/write.js

@@ -7,11 +7,15 @@ module.exports = function registerWriteNode(RED) {
     RED.nodes.createNode(this, config);
     const node = this;
     node.connection = RED.nodes.getNode(config.connection);
+    const consumer = node.connection?.registerConsumer?.('write', {
+      nodeId: config.id, name: config.name,
+    });
 
     node.on('input', async (msg, send, done) => {
       if (!node.connection) return done(new Error('OPC UA connection not configured'));
 
       try {
+        consumer?.markUsed('write');
         const points = messageWritePoints(msg, config);
         node.status({ fill: 'blue', shape: 'dot', text: `writing ${points.length}` });
         const results = await node.connection.client.writeMany(
@@ -41,6 +45,12 @@ module.exports = function registerWriteNode(RED) {
         done(error);
       }
     });
+
+    node.on('close', (removed, done) => {
+      if (typeof removed === 'function') done = removed;
+      consumer?.release();
+      done?.();
+    });
   }
 
   RED.nodes.registerType('tier0-opcua-write', OpcUaWriteNode);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tier0/opcua-client",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "High-scale OPC UA client nodes for Node-RED powered by open62541",
   "license": "Apache-2.0",
   "repository": {
@@ -38,7 +38,8 @@
     "test:stress": "node test/stress.js",
     "test:nodered": "node test/nodered.integration.js",
     "test:nodered:reconnect": "OPCUA_NODERED_RECONNECT=1 node test/nodered.integration.js",
-    "prepack": "node scripts/verify-offline-package.js"
+    "test:release": "npm test && npm run test:native && npm run test:offline-runtime && npm run test:nodered",
+    "prepack": "npm test && node scripts/verify-offline-package.js"
   },
   "keywords": [
     "node-red",

package/scripts/verify-offline-package.js

@@ -17,4 +17,24 @@ if (missing.length) {
   process.exit(1);
 }
 
-console.log('Offline package inputs verified');
+const packageJson = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const prebuildSize = fs.statSync(
+  path.join(root, 'prebuilds/linux-x64-musl/opcua_open62541.node')
+).size;
+const sourceSize = fs.statSync(
+  path.join(root, 'vendor/open62541-v1.4.16.tar.gz')
+).size;
+if (!packageJson.files?.includes('prebuilds') || !packageJson.files?.includes('vendor')) {
+  throw new Error('package.json files must include prebuilds and vendor for offline installation');
+}
+if (!packageJson.bundledDependencies?.includes('node-addon-api')) {
+  throw new Error('node-addon-api must remain a bundled dependency');
+}
+if (prebuildSize < 100000 || sourceSize < 1000000) {
+  throw new Error('Bundled native addon or open62541 source archive is unexpectedly small');
+}
+
+console.log(
+  `Offline package inputs verified for ${packageJson.name}@${packageJson.version}: ` +
+  `prebuild=${prebuildSize} bytes, open62541=${sourceSize} bytes`
+);