@vitormnm/node-red-simple-opcua 1.6.3 → 1.8.0

package/server/lib/opcua-address-space-builder.js

@@ -14,6 +14,8 @@ const {
 
 const { OpcUaAddressSpaceAlarm } = require("./opcua-address-space-alarm")
 
+const activeReads = new WeakMap();
+
 class OpcUaAddressSpaceBuilder {
     constructor(options) {
         this.namespace = options.namespace;
@@ -24,6 +26,7 @@ class OpcUaAddressSpaceBuilder {
         this.serverName = options.serverName;
         const hasUsers = Array.isArray(options.users) && options.users.length > 0;
         this.authorizationDisabled = !hasUsers;
+        this.users = options.users || [];
         this.nodeEntries = new Map();
         this.variableStore = new Map();
         this.variableNodeIdStore = new Map();
@@ -144,7 +147,7 @@ class OpcUaAddressSpaceBuilder {
                 return Number.isFinite(num) ? num : v;
             };
             if (record.isArray) {
-                val = Array.isArray(val) ? val.map(convertToNumber) : convertToNumber(val);
+                val = this.recursiveMap(val, convertToNumber, record.type);
             } else {
                 val = convertToNumber(val);
             }
@@ -196,7 +199,7 @@ class OpcUaAddressSpaceBuilder {
         const path = this.buildObjectTypePath(config.name);
         desiredEntries.set(path, this.buildEntryDefinition("objectTypeDefinition", config, path, "", "typeDefinition"));
         this.collectBranchChildren(desiredEntries, config, path, "componentOf", objectTypeConfigs, {
-            skipAlarms: false,
+            skipAlarms: true,
             preserveCollectionNames: true,
             typeRootPath: path
         });
@@ -758,11 +761,18 @@ class OpcUaAddressSpaceBuilder {
 
         const objectName = objectConfig.name;
         const nextPath = pathOverride || this.buildPath(parentPath, objectName);
+        const nodeId = this.resolveNodeId(objectConfig, nextPath, namespace);
+        const existingNode = addressSpace.findNode(nodeId);
+        if (existingNode) {
+            this.registerNodeEntry("object", nextPath, parentPath, relationship, objectConfig, existingNode, namespace);
+            return;
+        }
+
         const options = {
             browseName: objectConfig.displayName || objectName,
             displayName: objectConfig.displayName || objectName,
             description: objectConfig.description || "",
-            nodeId: this.resolveNodeId(objectConfig, nextPath, namespace),
+            nodeId: nodeId,
             rolePermissions: this.buildRolePermissions("object", objectConfig),
             eventNotifier: 1, //enabled_events,
             eventSourceOf: serverNode
@@ -784,47 +794,78 @@ class OpcUaAddressSpaceBuilder {
 
     addObjectTypeDefinition(objectTypeConfig) {
         const namespace = this.getNamespaceForConfig(objectTypeConfig);
+        const path = this.buildObjectTypePath(objectTypeConfig.name);
+        const nodeId = this.resolveNodeId(objectTypeConfig, path, namespace);
+        const addressSpace = this.server.engine.addressSpace;
+        const existingNode = addressSpace.findNode(nodeId);
+        if (existingNode) {
+            this.registerNodeEntry("objectTypeDefinition", path, "", "typeDefinition", objectTypeConfig, existingNode, namespace);
+            this.objectTypeStore.set(objectTypeConfig.name, {
+                node: existingNode,
+                config: objectTypeConfig,
+                path: path,
+                namespace: namespace
+            });
+            return;
+        }
+
         const objectTypeNode = namespace.addObjectType({
             browseName: objectTypeConfig.name,
             displayName: objectTypeConfig.displayName || objectTypeConfig.name,
             description: objectTypeConfig.description || "",
-            nodeId: this.resolveNodeId(objectTypeConfig, this.buildObjectTypePath(objectTypeConfig.name), namespace),
+            nodeId: nodeId,
             rolePermissions: this.buildRolePermissions("objectTypeDefinition", objectTypeConfig),
             subtypeOf: "BaseObjectType"
         });
 
 
-        const path = this.buildObjectTypePath(objectTypeConfig.name);
+        const path2 = this.buildObjectTypePath(objectTypeConfig.name);
 
 
 
-        this.registerNodeEntry("objectTypeDefinition", path, "", "typeDefinition", objectTypeConfig, objectTypeNode, namespace);
+        this.registerNodeEntry("objectTypeDefinition", path2, "", "typeDefinition", objectTypeConfig, objectTypeNode, namespace);
         this.objectTypeStore.set(objectTypeConfig.name, {
             node: objectTypeNode,
             config: objectTypeConfig,
-            path: path,
+            path: path2,
             namespace: namespace
         });
     }
 
     addEnumerationTypeDefinition(config) {
         const namespace = this.getNamespaceForConfig(config);
+        const path = this.buildEnumerationPath(config.name);
+        const nodeId = this.resolveNodeId(config, path, namespace);
+        const addressSpace = this.server.engine.addressSpace;
+        const existingNode = addressSpace.findNode(nodeId);
+        if (existingNode) {
+            this.registerNodeEntry("enumeration", path, "", "typeDefinition", config, existingNode, namespace);
+            if (!this.enumerationStore) this.enumerationStore = new Map();
+            this.enumerationStore.set(config.name, {
+                node: existingNode,
+                config: config,
+                path: path,
+                namespace: namespace
+            });
+            return;
+        }
+
         const enumTypeNode = namespace.addEnumerationType({
             browseName: config.displayName || config.name,
             displayName: config.displayName || config.name,
             description: config.description || "",
-            nodeId: this.resolveNodeId(config, this.buildEnumerationPath(config.name), namespace),
+            nodeId: nodeId,
             enumeration: config.enumeration
         });
 
-        const path = this.buildEnumerationPath(config.name);
+        const path2 = this.buildEnumerationPath(config.name);
 
-        this.registerNodeEntry("enumeration", path, "", "typeDefinition", config, enumTypeNode, namespace);
+        this.registerNodeEntry("enumeration", path2, "", "typeDefinition", config, enumTypeNode, namespace);
         if (!this.enumerationStore) this.enumerationStore = new Map();
         this.enumerationStore.set(config.name, {
             node: enumTypeNode,
             config: config,
-            path: path,
+            path: path2,
             namespace: namespace
         });
     }
@@ -835,18 +876,30 @@ class OpcUaAddressSpaceBuilder {
             throw new Error("Object type is not available for instance " + instanceConfig.name + ": " + instanceConfig.objectsType);
         }
 
+        const addressSpace = this.server.engine.addressSpace;
+        const serverNode = addressSpace.rootFolder.objects.server;
+
         const objectName = instanceConfig.name;
         const nextPath = pathOverride || this.buildPath(parentPath, objectName);
         const namespace = this.getNamespaceForConfig(instanceConfig);
+        const nodeId = this.resolveNodeId(instanceConfig, nextPath, namespace);
+
+        const existingNode = addressSpace.findNode(nodeId);
+        if (existingNode) {
+            this.registerNodeEntry("objectTypeInstance", nextPath, parentPath, relationship, instanceConfig, existingNode, namespace);
+            this.createInheritedChildren(existingNode, nextPath, instanceConfig, namespace);
+            return;
+        }
 
         const options = {
             browseName: instanceConfig.displayName || objectName,
             displayName: instanceConfig.displayName || objectName,
             description: instanceConfig.description || "",
-            nodeId: this.resolveNodeId(instanceConfig, nextPath, namespace),
+            nodeId: nodeId,
             rolePermissions: this.buildRolePermissions("objectTypeInstance", instanceConfig),
             typeDefinition: objectTypeEntry.node.nodeId,
-            eventNotifier: 1
+            eventNotifier: 1,
+            eventSourceOf: serverNode
         };
 
         if (relationship === "organizedBy") {
@@ -856,6 +909,21 @@ class OpcUaAddressSpaceBuilder {
         }
 
         const objectNode = namespace.addObject(options);
+
+        // Remove automatically instantiated children to let createInheritedChildren 
+        // create them with the correct rewritten NodeIds.
+        const autoChildren = [];
+        if (typeof objectNode.getComponents === "function") autoChildren.push(...objectNode.getComponents());
+        if (typeof objectNode.getProperties === "function") autoChildren.push(...objectNode.getProperties());
+        if (typeof objectNode.getMethods === "function") autoChildren.push(...objectNode.getMethods());
+        for (const child of autoChildren) {
+            try {
+                addressSpace.deleteNode(child.nodeId);
+            } catch (err) {
+                // Ignore
+            }
+        }
+
         this.registerNodeEntry("objectTypeInstance", nextPath, parentPath, relationship, instanceConfig, objectNode, namespace);
 
         // Create the inherited children explicitly using the configs that opcua-config.js
@@ -872,8 +940,8 @@ class OpcUaAddressSpaceBuilder {
         // Extract the type's nodeId value prefix (e.g. "Motor_type2") and the
         // instance's nodeId value prefix (e.g. "server1.newObjectType") so we can
         // rewrite every child nodeId from the type to the instance on-the-fly.
-        const typeNodeId = typeEntry.config.nodeId || "";
-        const instanceNodeId = instanceConfig.nodeId || "";
+        const typeNodeId = typeEntry.config.nodeId || ("ns=2;s=" + typeEntry.config.name);
+        const instanceNodeId = instanceConfig.nodeId || instanceNode.nodeId.toString();
         const typePrefix = this.extractNodeIdStringValue(typeNodeId);
         const instancePrefix = this.extractNodeIdStringValue(instanceNodeId);
 
@@ -881,24 +949,55 @@ class OpcUaAddressSpaceBuilder {
     }
 
     extractNodeIdStringValue(nodeId) {
-        const m = String(nodeId || "").match(/(?:^|;)s=(.+)$/);
+        const m = String(nodeId || "").match(/(?:^|;)[si]=(.+)$/);
         return m ? m[1] : "";
     }
 
     rewriteInheritedNodeId(nodeId, typePrefix, instancePrefix) {
         if (!nodeId || !typePrefix || !instancePrefix) return nodeId;
-        const m = String(nodeId).match(/^(ns=\d+;s=)([\s\S]*)$/);
+        const m = String(nodeId).match(/^(ns=\d+;[si]=)([\s\S]*)$/);
         if (m && m[2].startsWith(typePrefix)) {
             return m[1] + instancePrefix + m[2].slice(typePrefix.length);
         }
         return nodeId;
     }
 
+    /**
+     * Rewrites an alarm variableNodeId from the type to the instance.
+     * Handles three formats:
+     *   1. Full nodeId: "ns=2;s=motor.status" → "ns=2;s=myserver.motor01.status"
+     *   2. Plain type-relative path: "motor.status" → resolved to instance variable path
+     *   3. Bare variable name: "status" → resolved relative to instance path
+     */
+    rewriteInheritedAlarmVariableRef(variableRef, typePrefix, instancePrefix, instancePath) {
+        if (!variableRef) return variableRef;
+        const ref = String(variableRef).trim();
+
+        // Try full nodeId rewrite first (ns=X;s=...)
+        const rewritten = this.rewriteInheritedNodeId(ref, typePrefix, instancePrefix);
+        if (rewritten !== ref) {
+            return rewritten;
+        }
+
+        // Plain path starting with typePrefix (e.g. "motor.status" → "myserver.motor01.status")
+        if (typePrefix && instancePrefix && ref.startsWith(typePrefix)) {
+            return instancePrefix + ref.slice(typePrefix.length);
+        }
+
+        // Bare variable name (e.g. "status") → resolve relative to instance path
+        if (ref.indexOf(".") === -1 && instancePath) {
+            return this.buildPath(instancePath, ref);
+        }
+
+        return ref;
+    }
+
     createInheritedBranchChildren(typeConfig, parentOpcNode, parentPath, typePrefix, instancePrefix) {
         const variables = Array.isArray(typeConfig.variables) ? typeConfig.variables : [];
         const methods = Array.isArray(typeConfig.methods) ? typeConfig.methods : [];
         const folders = Array.isArray(typeConfig.folders) ? typeConfig.folders : [];
         const objects = Array.isArray(typeConfig.objects) ? typeConfig.objects : [];
+        const alarms = Array.isArray(typeConfig.alarms) ? typeConfig.alarms : [];
 
         variables.forEach((varConfig) => {
             const childPath = this.buildPath(parentPath, varConfig.name);
@@ -939,6 +1038,17 @@ class OpcUaAddressSpaceBuilder {
                 this.createInheritedBranchChildren(objectConfig, childNode, childPath, typePrefix, instancePrefix);
             }
         });
+
+        alarms.forEach((alarmConfig) => {
+            const childPath = this.buildPath(parentPath, alarmConfig.name);
+            const rewrittenConfig = Object.assign({}, alarmConfig, {
+                nodeId: this.rewriteInheritedNodeId(alarmConfig.nodeId, typePrefix, instancePrefix),
+                variableNodeId: this.rewriteInheritedAlarmVariableRef(
+                    alarmConfig.variableNodeId, typePrefix, instancePrefix, parentPath
+                )
+            });
+            this.addAlarm(parentOpcNode, rewrittenConfig, parentPath, "componentOf", childPath);
+        });
     }
 
     addAlarm(parentNode, alarmConfig, parentPath, relationship, pathOverride) {
@@ -971,19 +1081,52 @@ class OpcUaAddressSpaceBuilder {
 
             const sourceName = variableToMonitor.node.displayName[0].text
 
-            const browseName = alarmConfig.displayName || objectName
-            const inputNode = variableToMonitor.node
-
-
+            const browseName = alarmConfig.displayName || objectName;
+            const inputNode = variableToMonitor.node;
 
             const conditionName = alarmConfig.displayName || objectName
             const nodeId = this.resolveNodeId(alarmConfig, nextPath, namespace)
 
+            const addressSpace = this.server.engine.addressSpace;
+            const existingNode = addressSpace.findNode(nodeId);
+            if (existingNode) {
+                if (alarmConfig.type === "levelAlarm") {
+                    const lowLow = existingNode.getPropertyByName("lowLowLimit");
+                    if (lowLow) lowLow.setValueFromSource({ dataType: DataType.Int32, value: alarmConfig.lowLowLimit });
+                    const low = existingNode.getPropertyByName("lowLimit");
+                    if (low) low.setValueFromSource({ dataType: DataType.Int32, value: alarmConfig.lowLimit });
+                    const highHigh = existingNode.getPropertyByName("highHighLimit");
+                    if (highHigh) highHigh.setValueFromSource({ dataType: DataType.Int32, value: alarmConfig.highHighLimit });
+                    const high = existingNode.getPropertyByName("highLimit");
+                    if (high) high.setValueFromSource({ dataType: DataType.Int32, value: alarmConfig.highLimit });
+                }
+                const enabled = existingNode.getPropertyByName("enabled");
+                if (enabled) enabled.setValueFromSource({ dataType: DataType.Boolean, value: alarmConfig.enabled });
+                existingNode.sourceName.setValueFromSource({ dataType: DataType.String, value: sourceName });
+                existingNode.alarmConfig = alarmConfig;
+
+                const alarmRolePermissions = this.buildRolePermissions("alarm", alarmConfig);
+                if (alarmRolePermissions) {
+                    existingNode.setRolePermissions(alarmRolePermissions);
+                }
+                existingNode.path = nextPath;
+
+                variableToMonitor.alarm = {
+                    node: existingNode,
+                    alarmConfig: alarmConfig,
+                };
+                this.registerNodeEntry("alarm", nextPath, parentPath, relationship, alarmConfig, existingNode, namespace);
+                return;
+            }
+
             const alarmNode = this.addressSpaceAlarm.createAlarm(namespace, browseName, parentNode, inputNode, conditionName, nodeId, sourceName, alarmConfig)
             const alarmRolePermissions = this.buildRolePermissions("alarm", alarmConfig);
             if (alarmNode && alarmRolePermissions) {
                 alarmNode.setRolePermissions(alarmRolePermissions);
             }
+            if (alarmNode) {
+                alarmNode.path = nextPath;
+            }
 
 
 
@@ -1062,11 +1205,18 @@ class OpcUaAddressSpaceBuilder {
 
         const folderName = folderConfig.name;
         const nextPath = pathOverride || this.buildPath(parentPath, folderName);
+        const nodeId = this.resolveNodeId(folderConfig, nextPath, namespace);
+        const existingNode = addressSpace.findNode(nodeId);
+        if (existingNode) {
+            this.registerNodeEntry("folder", nextPath, parentPath, relationship, folderConfig, existingNode, namespace);
+            return;
+        }
+
         const options = {
             browseName: folderConfig.displayName || folderName,
             displayName: folderConfig.displayName || folderName,
             description: folderConfig.description || "",
-            nodeId: this.resolveNodeId(folderConfig, nextPath, namespace),
+            nodeId: nodeId,
             rolePermissions: this.buildRolePermissions("folder", folderConfig),
             typeDefinition: "FolderType",
             eventSourceOf: serverNode,
@@ -1103,13 +1253,97 @@ class OpcUaAddressSpaceBuilder {
         const path = pathOverride || this.buildPath(parentPath, name);
         const nodeId = this.resolveNodeId(variableConfig, path, namespace);
         const browseName = variableConfig.displayName || name;
+        let initialValue = variableConfig.value;
+        if (browseName === "AcceptAllCertificates" && this.server && this.server.serverCertificateManager) {
+            initialValue = this.server.serverCertificateManager.automaticallyAcceptUnknownCertificate;
+        }
+        
+        const dimensions = this.getArrayDimensions(initialValue, type);
         const state = {
             type,
             access,
-            isArray: this.isArrayValue(variableConfig.value),
-            currentValue: this.coerceValue(variableConfig.value, type, this.isArrayValue(variableConfig.value))
+            isArray: this.isArrayValue(initialValue),
+            isMatrix: !!dimensions,
+            dimensions: dimensions,
+            currentValue: this.coerceValue(initialValue, type, this.isArrayValue(initialValue))
         };
 
+        const addressSpace = this.server.engine.addressSpace;
+        const existingNode = addressSpace.findNode(nodeId);
+        if (existingNode) {
+            this.registerNodeEntry("variable", path, parentPath, "componentOf", variableConfig, existingNode, namespace);
+            const record = {
+                node: existingNode,
+                path: path,
+                nodeId: nodeId,
+                nodeIdKey: this.normalizeNodeIdKey(nodeId),
+                type: state.type,
+                isArray: state.isArray,
+                isMatrix: state.isMatrix,
+                dimensions: state.dimensions,
+                getValue: () => state.currentValue,
+                setRuntimeValue: (nextValue) => {
+                    if (state.isMatrix) {
+                        let parsedVal = nextValue;
+                        if (typeof nextValue === "string") {
+                            const trimmed = nextValue.trim();
+                            if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+                                parsedVal = JSON.parse(trimmed);
+                            }
+                        }
+                        const dims = this.getArrayDimensions(parsedVal, state.type);
+                        if (dims) {
+                            state.dimensions = dims;
+                            state.currentValue = this.coerceValue(parsedVal, state.type, true);
+                        } else {
+                            const coercedFlat = this.coerceValue(parsedVal, state.type, true);
+                            state.currentValue = this.reshapeArray(coercedFlat, state.dimensions);
+                        }
+                    } else {
+                        state.currentValue = this.coerceValue(nextValue, state.type, state.isArray);
+                    }
+                    return state.currentValue;
+                },
+                setValue: (nextValue) => {
+                    if (state.access !== "readwrite") {
+                        throw new Error("Tag is read-only: " + path);
+                    }
+
+                    if (state.isMatrix) {
+                        let parsedVal = nextValue;
+                        if (typeof nextValue === "string") {
+                            const trimmed = nextValue.trim();
+                            if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+                                parsedVal = JSON.parse(trimmed);
+                            }
+                        }
+                        const dims = this.getArrayDimensions(parsedVal, state.type);
+                        if (dims) {
+                            state.dimensions = dims;
+                            state.currentValue = this.coerceValue(parsedVal, state.type, true);
+                        } else {
+                            const coercedFlat = this.coerceValue(parsedVal, state.type, true);
+                            state.currentValue = this.reshapeArray(coercedFlat, state.dimensions);
+                        }
+                    } else {
+                        state.currentValue = this.coerceValue(nextValue, state.type, state.isArray);
+                    }
+
+                    const alarm = this.variableStore.get(path).alarm;
+                    if (alarm) this.addressSpaceAlarm.checkAlarm(alarm, state.currentValue);
+
+                    return state.currentValue;
+                }
+            };
+            this.variableStore.set(path, record);
+            this.variableNodeIdStore.set(record.nodeIdKey, record);
+            if (initialValue !== undefined) {
+                record.setRuntimeValue(initialValue);
+            }
+            this.wrapVariableNode(existingNode, path, nodeId, browseName, state);
+            return;
+        }
+
         const variableNode = namespace.addVariable({
             componentOf: parentNode,
             browseName,
@@ -1119,19 +1353,16 @@ class OpcUaAddressSpaceBuilder {
             rolePermissions: this.buildRolePermissions("variable", variableConfig),
             dataType: this.resolveDataType(type),
             modellingRule: this.isObjectTypePath(parentPath) ? "Mandatory" : undefined,
-            valueRank: state.isArray ? 1 : -1,
+            valueRank: state.isMatrix ? state.dimensions.length : (state.isArray ? 1 : -1),
+            arrayDimensions: state.isMatrix ? state.dimensions : undefined,
             accessLevel: access === "readwrite" ? "CurrentRead | CurrentWrite" : "CurrentRead",
             userAccessLevel: access === "readwrite" ? "CurrentRead | CurrentWrite" : "CurrentRead",
             minimumSamplingInterval: 500,
             value: {
                 get: () => {
-                    this.emitTagAccess("read", {
-                        path,
-                        nodeID: nodeId,
-                        browseName,
-                        dataType: state.type,
-                        value: state.currentValue
-                    });
+                    if (browseName === "AcceptAllCertificates" && this.server && this.server.serverCertificateManager) {
+                        state.currentValue = this.server.serverCertificateManager.automaticallyAcceptUnknownCertificate;
+                    }
 
                     let val = state.currentValue;
                     if (state.type === "Int64" || state.type === "UInt64") {
@@ -1151,7 +1382,7 @@ class OpcUaAddressSpaceBuilder {
                         };
 
                         if (state.isArray) {
-                            val = Array.isArray(val) ? val.map(bigIntToInt64Array) : [bigIntToInt64Array(val)];
+                            val = this.recursiveMap(val, bigIntToInt64Array, state.type);
                         } else {
                             val = bigIntToInt64Array(val);
                         }
@@ -1162,8 +1393,11 @@ class OpcUaAddressSpaceBuilder {
                         value: val
                     };
 
-                    // ByteString nunca e array - Buffer nao deve ser VariantArrayType.Array
-                    if (state.type !== "ByteString" && this.isArrayValue(state.currentValue)) {
+                    if (state.isMatrix) {
+                        variantOptions.arrayType = VariantArrayType.Matrix;
+                        variantOptions.dimensions = state.dimensions;
+                        variantOptions.value = this.flattenMatrix(val, state.type);
+                    } else if (state.type !== "ByteString" && this.isArrayValue(state.currentValue)) {
                         variantOptions.arrayType = VariantArrayType.Array;
                     } else if (state.type === "Int64" || state.type === "UInt64") {
                         variantOptions.arrayType = VariantArrayType.Scalar;
@@ -1177,25 +1411,32 @@ class OpcUaAddressSpaceBuilder {
                     }
 
                     try {
-                        state.currentValue = this.coerceValue(variant.value, state.type, state.isArray);
-                        this.emitTagAccess("write", {
-                            path,
-                            nodeID: nodeId,
-                            browseName,
-                            dataType: state.type,
-                            value: state.currentValue
-                        });
-
-                        const alarm = this.variableStore.get(path).alarm
-                        this.addressSpaceAlarm.checkAlarm(alarm, variant.value)
+                        let nextValue = variant.value;
+                        if (state.isMatrix) {
+                            const dims = variant.dimensions || state.dimensions;
+                            state.dimensions = dims;
+                            const coercedFlat = this.coerceValue(nextValue, state.type, true);
+                            state.currentValue = this.reshapeArray(coercedFlat, dims);
+                        } else {
+                            state.currentValue = this.coerceValue(nextValue, state.type, state.isArray);
+                        }
 
+                        if (browseName === "AcceptAllCertificates" && this.server && this.server.serverCertificateManager) {
+                            this.server.serverCertificateManager.automaticallyAcceptUnknownCertificate = !!state.currentValue;
+                            console.log(`AcceptAllCertificates updated by client to: ${state.currentValue}`);
+                            console.log(`Server Certificate Manager automaticallyAcceptUnknownCertificate is now: ${this.server.serverCertificateManager.automaticallyAcceptUnknownCertificate}`);
+                        }
 
+                        const record = this.variableStore.get(path);
+                        const alarm = record ? record.alarm : null;
+                        if (alarm) {
+                            this.addressSpaceAlarm.checkAlarm(alarm, variant.value);
+                        }
 
                         return StatusCodes.Good;
                     } catch (error) {
                         console.error("addVariable")
                         console.error(error)
-                        // this.node.warn("Rejected OPC UA write for " + path + ": " + error.message);
                         return StatusCodes.BadTypeMismatch;
                     }
                 }
@@ -1210,9 +1451,29 @@ class OpcUaAddressSpaceBuilder {
             nodeIdKey: this.normalizeNodeIdKey(nodeId),
             type: state.type,
             isArray: state.isArray,
+            isMatrix: state.isMatrix,
+            dimensions: state.dimensions,
             getValue: () => state.currentValue,
             setRuntimeValue: (nextValue) => {
-                state.currentValue = this.coerceValue(nextValue, state.type, state.isArray);
+                if (state.isMatrix) {
+                    let parsedVal = nextValue;
+                    if (typeof nextValue === "string") {
+                        const trimmed = nextValue.trim();
+                        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+                            parsedVal = JSON.parse(trimmed);
+                        }
+                    }
+                    const dims = this.getArrayDimensions(parsedVal, state.type);
+                    if (dims) {
+                        state.dimensions = dims;
+                        state.currentValue = this.coerceValue(parsedVal, state.type, true);
+                    } else {
+                        const coercedFlat = this.coerceValue(parsedVal, state.type, true);
+                        state.currentValue = this.reshapeArray(coercedFlat, state.dimensions);
+                    }
+                } else {
+                    state.currentValue = this.coerceValue(nextValue, state.type, state.isArray);
+                }
                 return state.currentValue;
             },
             setValue: (nextValue) => {
@@ -1220,7 +1481,25 @@ class OpcUaAddressSpaceBuilder {
                     throw new Error("Tag is read-only: " + path);
                 }
 
-                state.currentValue = this.coerceValue(nextValue, state.type, state.isArray);
+                if (state.isMatrix) {
+                    let parsedVal = nextValue;
+                    if (typeof nextValue === "string") {
+                        const trimmed = nextValue.trim();
+                        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+                            parsedVal = JSON.parse(trimmed);
+                        }
+                    }
+                    const dims = this.getArrayDimensions(parsedVal, state.type);
+                    if (dims) {
+                        state.dimensions = dims;
+                        state.currentValue = this.coerceValue(parsedVal, state.type, true);
+                    } else {
+                        const coercedFlat = this.coerceValue(parsedVal, state.type, true);
+                        state.currentValue = this.reshapeArray(coercedFlat, state.dimensions);
+                    }
+                } else {
+                    state.currentValue = this.coerceValue(nextValue, state.type, state.isArray);
+                }
 
                 const alarm = this.variableStore.get(path).alarm
                 this.addressSpaceAlarm.checkAlarm(alarm, state.currentValue)
@@ -1230,6 +1509,7 @@ class OpcUaAddressSpaceBuilder {
         };
         this.variableStore.set(path, record);
         this.variableNodeIdStore.set(record.nodeIdKey, record);
+        this.wrapVariableNode(variableNode, path, nodeId, browseName, state);
     }
 
 
@@ -1240,7 +1520,49 @@ class OpcUaAddressSpaceBuilder {
         const namespace = this.getNamespaceForConfig(methodConfig);
         const methodName = methodConfig.name;
         const path = pathOverride || this.buildPath(parentPath, methodName);
-        const nodeId = this.resolveNodeId(methodConfig, path, namespace)
+        const nodeId = this.resolveNodeId(methodConfig, path, namespace);
+
+        const addressSpace = this.server.engine.addressSpace;
+        const existingNode = addressSpace.findNode(nodeId);
+        if (existingNode) {
+            existingNode.bindMethod((inputArguments, context, callback) => {
+                const callId = Date.now() + "_" + Math.random();
+                const username = (context && context.session && context.session.userIdentityToken && context.session.userIdentityToken.userName)
+                    ? context.session.userIdentityToken.userName
+                    : "anonymous";
+
+                this.registry.emitMethodCall({
+                    methodName: methodConfig.name,
+                    nodeId: nodeId,
+                    callId,
+                    inputArguments,
+                    outputArguments: methodConfig.outputs.map((arg) => ({
+                        name: arg.name,
+                        description: { text: arg.description || "" },
+                        dataType: DATA_TYPE_MAP[arg.type]
+                    })),
+                    serverName: this.serverName,
+                    users: [{ name: username, groups: this.getUserGroups(username) }]
+                });
+
+                this.registry.waitForMethodResponse(callId)
+                    .then((outputs) => {
+                        callback(null, {
+                            statusCode: StatusCodes.Good,
+                            outputArguments: outputs.map((output) => new Variant(output))
+                        });
+                    })
+                    .catch(() => {
+                        callback(null, {
+                            statusCode: StatusCodes.BadInternalError
+                        });
+                    });
+            });
+
+            this.registerNodeEntry("method", path, parentPath, "componentOf", methodConfig, existingNode, namespace);
+            return;
+        }
+
         const methodNode = namespace.addMethod(parentNode, {
             browseName: methodConfig.displayName || methodName,
             displayName: methodConfig.displayName || methodName,
@@ -1262,6 +1584,9 @@ class OpcUaAddressSpaceBuilder {
 
         methodNode.bindMethod((inputArguments, context, callback) => {
             const callId = Date.now() + "_" + Math.random();
+            const username = (context && context.session && context.session.userIdentityToken && context.session.userIdentityToken.userName)
+                ? context.session.userIdentityToken.userName
+                : "anonymous";
 
             this.registry.emitMethodCall({
                 methodName: methodConfig.name,
@@ -1273,7 +1598,8 @@ class OpcUaAddressSpaceBuilder {
                     description: { text: arg.description || "" },
                     dataType: DATA_TYPE_MAP[arg.type]
                 })),
-                serverName: this.serverName
+                serverName: this.serverName,
+                users: [{ name: username, groups: this.getUserGroups(username) }]
             });
 
             this.registry.waitForMethodResponse(callId)
@@ -1388,6 +1714,238 @@ class OpcUaAddressSpaceBuilder {
         });
     }
 
+    getUserGroups(username) {
+        const normalized = String(username || "").trim();
+        if (!normalized || normalized.toLowerCase() === "anonymous") {
+            return [];
+        }
+        const user = this.users.find(u => u && u.username === normalized);
+        if (!user) {
+            return [];
+        }
+        return typeof user.group === "string"
+            ? user.group.split(",").map(g => g.trim()).filter(Boolean)
+            : Array.isArray(user.group)
+                ? user.group
+                : [];
+    }
+
+    emitTagAccessWithContext(operation, details, context) {
+        let val = details.value;
+        if (details.dataType === "Int64" || details.dataType === "UInt64") {
+            const convertToNumber = (v) => {
+                const num = Number(v);
+                return Number.isFinite(num) ? num : v;
+            };
+            const isArray = this.isArrayValue(val);
+            if (isArray) {
+                const items = this.extractArrayItems(val);
+                val = Array.isArray(items) ? items.map(convertToNumber) : convertToNumber(val);
+            } else {
+                val = convertToNumber(val);
+            }
+        }
+
+        const users = [];
+        if (context && context.session) {
+            const session = context.session;
+            const username = (session.userIdentityToken && session.userIdentityToken.userName)
+                ? session.userIdentityToken.userName
+                : "anonymous";
+            const groups = this.getUserGroups(username);
+            users.push({
+                name: username,
+                groups: groups
+            });
+        } else {
+            users.push({
+                name: "anonymous",
+                groups: []
+            });
+        }
+
+        this.registry.emitTagAccess({
+            operation,
+            serverId: this.node.id,
+            serverNodeName: this.node.name || "",
+            serverName: this.serverName,
+            timestamp: new Date().toISOString(),
+            path: details.path,
+            nodeID: details.nodeID,
+            browseName: details.browseName,
+            dataType: details.dataType,
+            value: val,
+            users: users
+        });
+    }
+
+    updateUsers(users) {
+        this.users = Array.isArray(users) ? users : [];
+    }
+
+    wrapVariableNode(variableNode, path, nodeId, browseName, state) {
+        // Guard: only wrap once per node instance — re-sync must not double-wrap
+        if (variableNode._opcuaWrapped) {
+            return;
+        }
+        variableNode._opcuaWrapped = true;
+        const self = this;
+
+        const originalReadValue = variableNode.readValue;
+        variableNode.readValue = function(...args) {
+            const context = args[0];
+            const hasActiveAsync = context && typeof context === "object" && activeReads.has(context);
+            try {
+                const dataValue = originalReadValue.apply(this, args);
+                if (!hasActiveAsync && dataValue && dataValue.statusCode.isGoodish()) {
+                    self.emitTagAccessWithContext("read", {
+                        path,
+                        nodeID: nodeId,
+                        browseName,
+                        dataType: state.type,
+                        value: (dataValue.value) ? dataValue.value.value : null
+                    }, context);
+                }
+                return dataValue;
+            } finally {
+                // no-op
+            }
+        };
+
+        const originalReadValueAsync = variableNode.readValueAsync;
+        variableNode.readValueAsync = function(...args) {
+            let callback = null;
+            if (args.length > 0 && typeof args[args.length - 1] === "function") {
+                callback = args[args.length - 1];
+            }
+
+            const context = args[0];
+
+            if (context && typeof context === "object") {
+                activeReads.set(context, true);
+            }
+
+            if (callback) {
+                args[args.length - 1] = function(err, dataValue) {
+                    if (context && typeof context === "object") {
+                        activeReads.delete(context);
+                    }
+                    if (!err && dataValue && dataValue.statusCode.isGoodish()) {
+                        self.emitTagAccessWithContext("read", {
+                            path,
+                            nodeID: nodeId,
+                            browseName,
+                            dataType: state.type,
+                            value: (dataValue.value) ? dataValue.value.value : null
+                        }, context);
+                    }
+                    callback(err, dataValue);
+                };
+                try {
+                    return originalReadValueAsync.apply(this, args);
+                } catch (e) {
+                    if (context && typeof context === "object") {
+                        activeReads.delete(context);
+                    }
+                    throw e;
+                }
+            } else {
+                try {
+                    const promise = originalReadValueAsync.apply(this, args);
+                    if (promise && typeof promise.then === "function") {
+                        return promise.then((dataValue) => {
+                            if (context && typeof context === "object") {
+                                activeReads.delete(context);
+                            }
+                            if (dataValue && dataValue.statusCode.isGoodish()) {
+                                self.emitTagAccessWithContext("read", {
+                                    path,
+                                    nodeID: nodeId,
+                                    browseName,
+                                    dataType: state.type,
+                                    value: (dataValue.value) ? dataValue.value.value : null
+                                }, context);
+                            }
+                            return dataValue;
+                        }, (err) => {
+                            if (context && typeof context === "object") {
+                                activeReads.delete(context);
+                            }
+                            throw err;
+                        });
+                    }
+                    if (context && typeof context === "object") {
+                        activeReads.delete(context);
+                    }
+                    return promise;
+                } catch (e) {
+                    if (context && typeof context === "object") {
+                        activeReads.delete(context);
+                    }
+                    throw e;
+                }
+            }
+        };
+
+        const originalWriteValue = variableNode.writeValue;
+        variableNode.writeValue = function(...args) {
+            let callback = null;
+            if (args.length > 0 && typeof args[args.length - 1] === "function") {
+                callback = args[args.length - 1];
+            }
+
+            const context = args[0];
+            const dataValue = args[1];
+
+            const prevContext = self.registry.activeWriteContext;
+            self.registry.activeWriteContext = context;
+
+            if (callback) {
+                args[args.length - 1] = function(err, statusCode) {
+                    self.registry.activeWriteContext = prevContext;
+                    if (!err && statusCode && statusCode.isGoodish()) {
+                        self.emitTagAccessWithContext("write", {
+                            path,
+                            nodeID: nodeId,
+                            browseName,
+                            dataType: state.type,
+                            value: (dataValue && dataValue.value) ? dataValue.value.value : null
+                        }, context);
+                    }
+                    callback(err, statusCode);
+                };
+                try {
+                    return originalWriteValue.apply(this, args);
+                } catch (err) {
+                    self.registry.activeWriteContext = prevContext;
+                    throw err;
+                }
+            } else {
+                try {
+                    return originalWriteValue.apply(this, args).then((statusCode) => {
+                        self.registry.activeWriteContext = prevContext;
+                        if (statusCode && statusCode.isGoodish()) {
+                            self.emitTagAccessWithContext("write", {
+                                path,
+                                nodeID: nodeId,
+                                browseName,
+                                dataType: state.type,
+                                value: (dataValue && dataValue.value) ? dataValue.value.value : null
+                            }, context);
+                        }
+                        return statusCode;
+                    }).catch((err) => {
+                        self.registry.activeWriteContext = prevContext;
+                        throw err;
+                    });
+                } catch (err) {
+                    self.registry.activeWriteContext = prevContext;
+                    throw err;
+                }
+            }
+        };
+    }
+
     getVariableRecord(identifierType, identifier) {
         if (identifierType === "nodeId") {
             return this.getVariableRecordByNodeId(identifier);
@@ -1425,13 +1983,6 @@ class OpcUaAddressSpaceBuilder {
 
         if (reference.indexOf(".") === 0) {
             const relativeReference = this.resolveObjectTypeRelativeReference(parentPath, reference);
-
-            //not work
-            var corrente = parentNode.getComponentByName("corrent")
-
-            return {
-                node: corrente
-            }
             if (this.variableStore.has(relativeReference)) {
                 return this.variableStore.get(relativeReference);
             }
@@ -1531,7 +2082,7 @@ class OpcUaAddressSpaceBuilder {
                 throw new Error("Expected array value for type " + type);
             }
 
-            return items.map((item) => this.coerceScalarValue(item, type));
+            return this.recursiveMap(items, (item) => this.coerceScalarValue(item, type), type);
         }
 
         if (typeof value === "string") {
@@ -1727,6 +2278,113 @@ class OpcUaAddressSpaceBuilder {
 
         return null;
     }
+
+    getArrayDimensions(value, type) {
+        const arr = this.extractArrayItems(value);
+        if (!arr) {
+            return null;
+        }
+
+        // Standard check: is it an Int64/UInt64 scalar represented as [high, low]?
+        if ((type === "Int64" || type === "UInt64") && arr.length === 2 && typeof arr[0] === "number" && typeof arr[1] === "number") {
+            return null;
+        }
+
+        const hasNestedArray = arr.some(item => {
+            if (Array.isArray(item)) {
+                if ((type === "Int64" || type === "UInt64") && item.length === 2 && typeof item[0] === "number" && typeof item[1] === "number") {
+                    return false;
+                }
+                return true;
+            }
+            return false;
+        });
+
+        if (!hasNestedArray) {
+            return null;
+        }
+
+        const dimensions = [];
+        let current = arr;
+        while (Array.isArray(current)) {
+            if ((type === "Int64" || type === "UInt64") && current.length === 2 && typeof current[0] === "number" && typeof current[1] === "number") {
+                break;
+            }
+            dimensions.push(current.length);
+            if (current.length === 0) {
+                break;
+            }
+            current = current[0];
+        }
+        return dimensions;
+    }
+
+    flattenMatrix(value, type) {
+        const arr = this.extractArrayItems(value);
+        if (!arr) {
+            return value;
+        }
+        if ((type === "Int64" || type === "UInt64") && arr.length === 2 && typeof arr[0] === "number" && typeof arr[1] === "number") {
+            return [arr];
+        }
+
+        const flat = [];
+        const recurse = (a) => {
+            for (const item of a) {
+                if (Array.isArray(item)) {
+                    if ((type === "Int64" || type === "UInt64") && item.length === 2 && typeof item[0] === "number" && typeof item[1] === "number") {
+                        flat.push(item);
+                    } else {
+                        recurse(item);
+                    }
+                } else {
+                    flat.push(item);
+                }
+            }
+        };
+        recurse(arr);
+        return flat;
+    }
+
+    reshapeArray(flatArray, dimensions) {
+        if (!dimensions || dimensions.length <= 1) {
+            return flatArray;
+        }
+
+        const reshape = (arr, dims, offset) => {
+            const size = dims[0];
+            if (dims.length === 1) {
+                return {
+                    result: arr.slice(offset, offset + size),
+                    nextOffset: offset + size
+                };
+            }
+
+            const result = [];
+            let currentOffset = offset;
+            for (let i = 0; i < size; i++) {
+                const step = reshape(arr, dims.slice(1), currentOffset);
+                result.push(step.result);
+                currentOffset = step.nextOffset;
+            }
+            return {
+                result: result,
+                nextOffset: currentOffset
+            };
+        };
+
+        return reshape(flatArray, dimensions, 0).result;
+    }
+
+    recursiveMap(val, fn, type) {
+        if (Array.isArray(val)) {
+            if ((type === "Int64" || type === "UInt64") && val.length === 2 && typeof val[0] === "number" && typeof val[1] === "number") {
+                return fn(val);
+            }
+            return val.map(item => this.recursiveMap(item, fn, type));
+        }
+        return fn(val);
+    }
 }
 
 function collapsePaths(paths) {