@vitormnm/node-red-simple-opcua 1.7.0 → 1.8.1

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);
             }
@@ -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
         });
     }
@@ -841,12 +882,20 @@ class OpcUaAddressSpaceBuilder {
         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,
@@ -860,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
@@ -876,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);
 
@@ -1017,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;
+            }
 
 
 
@@ -1108,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,
@@ -1153,13 +1257,93 @@ class OpcUaAddressSpaceBuilder {
         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(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,
@@ -1169,7 +1353,8 @@ 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,
@@ -1178,13 +1363,6 @@ class OpcUaAddressSpaceBuilder {
                     if (browseName === "AcceptAllCertificates" && this.server && this.server.serverCertificateManager) {
                         state.currentValue = this.server.serverCertificateManager.automaticallyAcceptUnknownCertificate;
                     }
-                    this.emitTagAccess("read", {
-                        path,
-                        nodeID: nodeId,
-                        browseName,
-                        dataType: state.type,
-                        value: state.currentValue
-                    });
 
                     let val = state.currentValue;
                     if (state.type === "Int64" || state.type === "UInt64") {
@@ -1204,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);
                         }
@@ -1215,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;
@@ -1230,14 +1411,15 @@ 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
-                        });
+                        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;
@@ -1245,14 +1427,16 @@ class OpcUaAddressSpaceBuilder {
                             console.log(`Server Certificate Manager automaticallyAcceptUnknownCertificate is now: ${this.server.serverCertificateManager.automaticallyAcceptUnknownCertificate}`);
                         }
 
-                        const alarm = this.variableStore.get(path).alarm
-                        this.addressSpaceAlarm.checkAlarm(alarm, variant.value)
+                        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;
                     }
                 }
@@ -1267,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) => {
@@ -1277,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)
@@ -1287,6 +1509,7 @@ class OpcUaAddressSpaceBuilder {
         };
         this.variableStore.set(path, record);
         this.variableNodeIdStore.set(record.nodeIdKey, record);
+        this.wrapVariableNode(variableNode, path, nodeId, browseName, state);
     }
 
 
@@ -1297,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,
@@ -1319,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,
@@ -1330,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)
@@ -1445,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);
@@ -1581,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") {
@@ -1777,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) {