node-opcua-address-space 2.181.1 → 2.182.2

package/impl/nodeset_tools/nodeset_to_xml.ts

@@ -23,12 +23,29 @@ import { type LocalizedText, makeAccessLevelFlag, NodeClass, QualifiedName } fro
 import { make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import type { ExtensionObject } from "node-opcua-extension-object";
 import { NodeId, NodeIdType } from "node-opcua-nodeid";
+import { StatusCodes } from "node-opcua-status-code";
 import { EnumDefinition, StructureDefinition, StructureType } from "node-opcua-types";
 import { isNullOrUndefined, lowerFirstLetter } from "node-opcua-utils";
 import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
 import XMLWriter from "xml-writer";
 import { makeDefinitionMap } from "../../api/loader/decode_xml_extension_object.js";
 import type { DefinitionMap2 } from "../../api/loader/make_xml_extension_object_parser.js";
+import {
+    _dumpLocalizedText,
+    _dumpNodeId,
+    _dumpQualifiedName,
+    _dumpXmlElement,
+    b,
+    coerceInt64ToInt32,
+    findXsdNamespaceUri,
+    getPrefix,
+    initXmlWriterEx,
+    int64ToDecimalString,
+    makeTypeXsd,
+    n,
+    restoreDefaultNamespace,
+    startElementEx
+} from "../../api/loader/nodeset_xml_primitives.js";
 import { SessionContext } from "../../api/session_context.js";
 import type { XmlWriter } from "../../api/xml_writer.js";
 import { BaseNodeImpl, getReferenceType } from "../base_node_impl.js";
@@ -46,6 +63,8 @@ import {
 } from "./construct_namespace_dependency.js";
 import { type NodesetWalkEvent, namespaceToWalkEvents, nodeToWalkEvents, sortByNodeId } from "./nodeset_to_records.js";
 
+export { coerceInt64ToInt32, initXmlWriterEx, makeTypeXsd } from "../../api/loader/nodeset_xml_primitives.js";
+
 const debugLog = make_debugLog("nodeset_to_xml");
 const warningLog = make_warningLog("nodeset_to_xml");
 const errorLog = make_errorLog("nodeset_to_xml");
@@ -70,28 +89,6 @@ function _dumpDescription(xw: XmlWriter, node: { description?: LocalizedText }):
     }
 }
 
-function translateNodeId(xw: XmlWriter, nodeId: NodeId): NodeId {
-    assert(nodeId instanceof NodeId);
-    const nn = xw.translationTable.get(nodeId.namespace);
-    const translatedNode = new NodeId(nodeId.identifierType, nodeId.value, nn);
-    return translatedNode;
-}
-
-function n(xw: XmlWriter, nodeId: NodeId): string {
-    return translateNodeId(xw, nodeId).toString().replace("ns=0;", "");
-}
-
-function translateBrowseName(xw: XmlWriter, browseName: QualifiedName): QualifiedName {
-    assert(browseName instanceof QualifiedName);
-    const nn = xw.translationTable.get(browseName.namespaceIndex);
-    const translatedBrowseName = new QualifiedName({ namespaceIndex: nn, name: browseName.name });
-    return translatedBrowseName;
-}
-
-function b(xw: XmlWriter, browseName: QualifiedName): string {
-    return translateBrowseName(xw, browseName).toString().replace("ns=0;", "");
-}
-
 function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2: number, priorityTable: number[]) {
     const order1 = priorityTable[namespaceIndex1];
     const order2 = priorityTable[namespaceIndex2];
@@ -129,6 +126,7 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
     // below already tolerates it being absent.
     const connectsToReferenceType = addressSpace.findReferenceType("ConnectsTo");
     const hasEventSourceReferenceType = _mustFindReferenceType(addressSpace, "HasEventSource");
+    const hierarchicalReferencesType = _mustFindReferenceType(addressSpace, "HierarchicalReferences");
 
     function referenceToKeep(reference: UAReference): boolean {
         // resolved here: a reference nobody has looked at since the load carries only the NodeId of its type
@@ -165,10 +163,26 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
         } else if (referenceType.isSubtypeOf(organizesReferencesType) && !reference.isForward) {
             // Organizes inverse — the current node is organized by an external folder
             return true;
+        } else if (referenceType.isSubtypeOf(organizesReferencesType) && reference.isForward) {
+            // Organizes forward into another namespace: the target lives in a document this export
+            // does not write, so nothing else will ever declare this reference and dropping it
+            // loses it outright. Within our own namespace the target declares the inverse and this
+            // end stays silent, exactly as the Aggregates branch above decides it
+            return targetedNamespaceIndex !== node.nodeId.namespace;
         } else if (connectsToReferenceType && referenceType.isSubtypeOf(connectsToReferenceType) && reference.isForward) {
             return true;
         } else if (referenceType.isSubtypeOf(hasEventSourceReferenceType) && reference.isForward) {
             return true;
+        } else if (referenceType.isSubtypeOf(hierarchicalReferencesType)) {
+            // a hierarchical reference type the branches above do not name: a companion
+            // specification's own, such as Robotics' Requires, Controls and HasSafetyStates. Those
+            // fell through to `return false` and were dropped in both directions, so a nodeset that
+            // defines its own hierarchical reference type lost every reference that used it.
+            // Decided the way Aggregates is decided just above: this end writes the reference
+            // unless the other end has the higher priority and will write it instead
+            return reference.isForward
+                ? !_hasHigherPriorityThan(xw, targetedNamespaceIndex, node.nodeId.namespace)
+                : targetedNamespaceIndex !== node.nodeId.namespace;
         }
         return false;
     }
@@ -192,36 +206,6 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
     }
     xw.endElement();
 }
-function _dumpLocalizedText(xw: XmlWriter, v: LocalizedText) {
-    const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
-    if (v.locale?.length) {
-        xw.startElement(`${uax}Locale`);
-        xw.text(v.locale);
-        xw.endElement();
-    }
-    xw.startElement(`${uax}Text`);
-    if (v.text) {
-        xw.text(v.text);
-    }
-    xw.endElement();
-}
-function _dumpQualifiedName(xw: XmlWriter, v: QualifiedName) {
-    const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
-    const t = translateBrowseName(xw, v);
-    if (t.name) {
-        xw.startElement(`${uax}Name`);
-        xw.text(t.name);
-        xw.endElement();
-    }
-    if (t.namespaceIndex) {
-        xw.startElement(`${uax}NamespaceIndex`);
-        xw.text(t.namespaceIndex.toString());
-        xw.endElement();
-    }
-}
-function _dumpXmlElement(xw: XmlWriter, v: string) {
-    xw.text(v);
-}
 /*
 <uax:ExtensionObject>
     <uax:TypeId>
@@ -239,78 +223,6 @@ function _dumpXmlElement(xw: XmlWriter, v: string) {
     </uax:Body>
 </uax:ExtensionObject>
 */
-type XmlNamespaceUri = string;
-type NamespaceUri = string;
-type XmlNs = string;
-interface XmlWriterEx extends XmlWriter {
-    map: Record<XmlNamespaceUri, XmlNs>;
-    stackMap: Record<XmlNamespaceUri, XmlNs>[];
-    namespaceArray: NamespaceUri[];
-}
-export function initXmlWriterEx(xw: XmlWriter, map: Record<XmlNamespaceUri, XmlNs>, namespaceArray: NamespaceUri[]): void {
-    const xwe = xw as XmlWriterEx;
-    xwe.map = map;
-    xwe.stackMap = [];
-    xwe.namespaceArray = namespaceArray;
-}
-function findXsdNamespaceUri(xw: XmlWriter, nodeId: NodeId): string {
-    const xwe = xw as XmlWriterEx;
-    if (!xwe.namespaceArray) {
-        return "";
-    }
-    const namespace = xwe.namespaceArray[nodeId.namespace];
-    if (namespace === "http://opcfoundation.org/UA/") {
-        return "http://opcfoundation.org/UA/2008/02/Types.xsd";
-    }
-    // c8 ignore next
-    if (!namespace) {
-        return "";
-    }
-    return `${namespace.replace(/\/$/, "")}/Types.xsd`;
-}
-
-function getPrefix(xw: XmlWriter, namespace: XmlNamespaceUri): XmlNs {
-    const xwe = xw as XmlWriterEx;
-    if (!xwe.map) return "";
-    const p = xwe.map[namespace] || "";
-    return p ? `${p}:` : "";
-}
-
-function restoreDefaultNamespace(xw: XmlWriter) {
-    const xwe = xw as XmlWriterEx;
-    if (!xwe.map) return;
-    const previousMap = xwe.stackMap.pop();
-    if (previousMap) {
-        xwe.map = previousMap;
-    }
-}
-
-function setDefaultNamespace(xw: XmlWriter, namespace: XmlNamespaceUri): void {
-    const xwe = xw as XmlWriterEx;
-    if (!xwe.map) return;
-    if (xwe.map[namespace] !== "") {
-        xw.writeAttribute("xmlns", namespace);
-    }
-
-    xwe.stackMap.push({
-        ...xwe.map
-    });
-    xwe.map[namespace] = "";
-}
-
-function startElementEx(xw: XmlWriter, _ns: XmlNs, name: string, defaultNamespace: XmlNamespaceUri) {
-    const _xwe = xw as XmlWriterEx;
-    xw.startElement(name);
-    setDefaultNamespace(xw, defaultNamespace);
-}
-
-function _dumpNodeId(xw: XmlWriter, v: NodeId) {
-    const xmlns = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
-    xw.startElement(`${xmlns}Identifier`);
-    xw.text(n(xw, v));
-    xw.endElement();
-}
-
 function _dumpVariantValue(xw: XmlWriter, dataTypeNodeId: NodeId, dataType: DataType, addressSpace: IAddressSpace, value: unknown) {
     if (value === undefined || value === null) {
         return;
@@ -449,7 +361,7 @@ function _dumpVariantInnerValue(
             break;
         case DataType.Int64:
         case DataType.UInt64:
-            xw.text((value as [number, number])[1].toString());
+            xw.text(int64ToDecimalString(value as Int64, dataType === DataType.Int64));
             break;
         case DataType.Boolean:
         case DataType.SByte:
@@ -662,7 +574,6 @@ function _dumpValue(xw: XmlWriter, node: UAVariable | UAVariableType, variant: V
         return;
     }
 
-    const dataTypeName = dataTypeNode.browseName.name?.toString();
     const baseDataTypeName = DataType[variant.dataType];
 
     if (baseDataTypeName === "Null") {
@@ -673,9 +584,13 @@ function _dumpValue(xw: XmlWriter, node: UAVariable | UAVariableType, variant: V
     // determine if dataTypeName is a ExtensionObject
     const isExtensionObject = variant.dataType === DataType.ExtensionObject;
 
-    if (_isDefaultValue(variant)) {
+    // nothing to serialize: a scalar with no value, or an array that is null rather than empty.
+    // This is the one thing _isDefaultValue used to catch here that still needs catching -- it is
+    // a test for the absence of a value, not for a value that happens to equal a type's default
+    if (variant.value === null || variant.value === undefined) {
         return;
     }
+
     xw.startElement("Value");
 
     const uax = getPrefix(xw, "http://opcfoundation.org/UA/2008/02/Types.xsd");
@@ -702,7 +617,11 @@ function _dumpValue(xw: XmlWriter, node: UAVariable | UAVariableType, variant: V
         switch (variant.arrayType) {
             case VariantArrayType.Matrix:
             case VariantArrayType.Array:
-                startElementEx(xw, uax, `ListOf${dataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
+                // the built-in type, not the DataType's browse name: the uax schema defines
+                // ListOfInt32 and ListOfString, and nothing named after a nodeset's own DataType.
+                // A `ListOfIdType` is not an element any reader knows, so the reader that meets it
+                // walks straight past into the first child and takes the array for a scalar
+                startElementEx(xw, uax, `ListOf${baseDataTypeName}`, "http://opcfoundation.org/UA/2008/02/Types.xsd");
                 variant.value.forEach(encodeXml);
                 restoreDefaultNamespace(xw);
                 xw.endElement();
@@ -720,12 +639,15 @@ function _dumpValue(xw: XmlWriter, node: UAVariable | UAVariableType, variant: V
 }
 
 function _dumpArrayDimensionsAttribute(xw: XmlWriter, node: UAVariableType | UAVariable) {
-    if (node.arrayDimensions) {
-        if (node.valueRank === -1 || (node.arrayDimensions.length === 1 && node.arrayDimensions[0] === 0)) {
-            return;
-        }
-        xw.writeAttribute("ArrayDimensions", node.arrayDimensions.join(","));
-    }
+    // ArrayDimensions="0" is written only when the document declared it: node-opcua synthesizes [0]
+    // on the variables it generates, so writing it unconditionally would invent the attribute on
+    // every generated node. See arrayDimensionsWereDeclared in nodeset_record_applier
+    if (!node.arrayDimensions || node.valueRank <= 0) return;
+    // all-zero dimensions are what node-opcua synthesizes when nobody declared any, at whatever
+    // rank: [0] for a one-dimensional value, [0,0] for a matrix
+    const degenerate = node.arrayDimensions.every((d) => d === 0);
+    if (degenerate && !(node as unknown as { arrayDimensionsWereDeclared?: boolean }).arrayDimensionsWereDeclared) return;
+    xw.writeAttribute("ArrayDimensions", node.arrayDimensions.join(","));
 }
 
 function getParent(node: BaseNode): BaseNode | null {
@@ -749,6 +671,10 @@ function dumpCommonAttributes(xw: XmlWriter, node: BaseNode) {
     if (Object.hasOwn(node, "symbolicName")) {
         xw.writeAttribute("SymbolicName", (node as unknown as { symbolicName: string }).symbolicName);
     }
+    // Released is the default and is left unwritten; the other two the document declared
+    if (node.releaseStatus) {
+        xw.writeAttribute("ReleaseStatus", node.releaseStatus);
+    }
     if (Object.hasOwn(node, "isAbstract")) {
         const isAbstract = (node as unknown as { isAbstract: boolean }).isAbstract;
         if (isAbstract) {
@@ -773,8 +699,11 @@ function dumpCommonAttributes(xw: XmlWriter, node: BaseNode) {
     }
     // access policy: undefined means "inherit from the namespace", an empty rolePermissions array
     // means "this node deliberately grants nothing".
-    if (node.accessRestrictions !== undefined) {
-        xw.writeAttribute("AccessRestrictions", node.accessRestrictions.toString());
+    // what the document declared, which survives whatever the loader was asked to enforce; the
+    // enforced flag is the fallback for a node built in code rather than loaded
+    const accessRestrictions = node.declaredAccessRestrictions ?? node.accessRestrictions?.toString();
+    if (accessRestrictions !== undefined) {
+        xw.writeAttribute("AccessRestrictions", accessRestrictions);
     }
     if (node.rolePermissions !== undefined && node.rolePermissions.length === 0) {
         xw.writeAttribute("HasNoPermissions", "true");
@@ -785,6 +714,19 @@ function dumpCommonAttributes(xw: XmlWriter, node: BaseNode) {
             xw.writeAttribute("MinimumSamplingInterval", minimumSamplingInterval);
         }
     }
+    // EventNotifier lives on UAObject, UAObjectType and UAView in the XSD. 0 is the default and is
+    // left unwritten; anything else the document declared. It was written nowhere at all until now,
+    // so every node that declared one lost it on the way out
+    if (node.nodeClass === NodeClass.Object || node.nodeClass === NodeClass.ObjectType || node.nodeClass === NodeClass.View) {
+        // typeof, not truthiness: a node with a child called "EventNotifier" resolves the name to
+        // that child through the shared child accessors, so `node.eventNotifier` is a BaseNode
+        // there and not the attribute. PublishedEventsType is one, and stringifying it wrote a
+        // whole node dump into the attribute
+        const eventNotifier = (node as unknown as { eventNotifier?: unknown }).eventNotifier;
+        if (typeof eventNotifier === "number" && eventNotifier !== 0) {
+            xw.writeAttribute("EventNotifier", eventNotifier.toString());
+        }
+    }
     // Historizing exists in the XSD on UAVariable only: UAVariableType is restricted to
     // DataType/ValueRank/ArrayDimensions. UAVariableTypeImpl nevertheless owns a `historizing`
     // property, so the node class must be tested here rather than the presence of the property.
@@ -819,19 +761,6 @@ function dumpCommonElements(xw: XmlWriter, node: BaseNode) {
     _dumpRolePermissions(xw, node);
 }
 
-export function coerceInt64ToInt32(int64: Int64): number {
-    if (typeof int64 === "number") {
-        return int64 as number;
-    }
-    if (int64[0] === 0xffffffff && int64[1] === 0xffffffff) {
-        return 0xffffffff;
-    }
-    if (int64[0] !== 0) {
-        warningLog("coerceInt64ToInt32 , loosing high word in conversion");
-    }
-    return int64[1];
-}
-
 function _dumpEnumDefinition(xw: XmlWriter, enumDefinition: EnumDefinition) {
     enumDefinition.fields = enumDefinition.fields || [];
 
@@ -860,6 +789,12 @@ function _dumpStructureDefinition(
     // do not repeat elements that are already defined in base structure in the xml ouput!
     const fields = structureDefinition.fields || [];
     const nbFieldsInBase: number = baseStructureDefinition ? baseStructureDefinition.fields?.length || 0 : 0;
+    // Part 3 8.51: in a *WithSubtypedValues structure, isOptional is where "subtyping allowed" is
+    // held, and the document spells that AllowSubTypes. Written as IsOptional it said the opposite
+    // of what it meant, and the AllowSubTypes the document had was simply gone
+    const subtypedValues =
+        structureDefinition.structureType === StructureType.StructureWithSubtypedValues ||
+        structureDefinition.structureType === StructureType.UnionWithSubtypedValues;
 
     for (let index = nbFieldsInBase; index < fields.length; index++) {
         const defItem = fields[index];
@@ -872,8 +807,8 @@ function _dumpStructureDefinition(
         if (defItem.valueRank !== undefined && defItem.valueRank !== -1) {
             xw.writeAttribute("ValueRank", defItem.valueRank);
         }
-        if (defItem.isOptional /* && defItem.isOptional !== false */) {
-            xw.writeAttribute("IsOptional", defItem.isOptional.toString());
+        if (defItem.isOptional) {
+            xw.writeAttribute(subtypedValues ? "AllowSubTypes" : "IsOptional", "true");
         }
         if (defItem.maxStringLength !== undefined && defItem.maxStringLength !== 0) {
             xw.writeAttribute("MaxStringLength", defItem.maxStringLength);
@@ -892,9 +827,37 @@ function _dumpStructureDefinition(
 function _dumpUADataTypeDefinition(xw: XmlWriter, uaDataType: UADataType) {
     const uaDataTypeBase = uaDataType.subtypeOfObj;
 
+    // an OptionSet first: node-opcua builds neither an enumeration nor a structure for one, so
+    // neither branch below would fire and the whole <Definition> would be dropped. The fields are
+    // the ones the loader kept, see UADataTypeImpl.isOptionSetDataType
+    const asImpl = uaDataType as unknown as {
+        isOptionSetDataType?: boolean;
+        declaredDefinitionFields?: Array<{ name?: string | null; value?: number; description?: unknown }>;
+        declaredDefinitionName?: string;
+    };
+    // what the document called this definition, or -- for a DataType built here, which never had a
+    // declaration -- the browse name, which is the only name available
+    const definitionName = asImpl.declaredDefinitionName ?? b(xw, uaDataType.browseName);
+    if (asImpl.isOptionSetDataType && asImpl.declaredDefinitionFields) {
+        xw.startElement("Definition");
+        xw.writeAttribute("Name", definitionName);
+        xw.writeAttribute("IsOptionSet", "true");
+        for (const field of asImpl.declaredDefinitionFields) {
+            xw.startElement("Field");
+            xw.writeAttribute("Name", field.name || "");
+            if (field.value !== undefined && field.value !== null) {
+                xw.writeAttribute("Value", field.value);
+            }
+            _dumpDescription(xw, field as { description?: LocalizedText });
+            xw.endElement();
+        }
+        xw.endElement();
+        return;
+    }
+
     if (uaDataType.isEnumeration()) {
         xw.startElement("Definition");
-        xw.writeAttribute("Name", b(xw, uaDataType.browseName));
+        xw.writeAttribute("Name", definitionName);
         _dumpEnumDefinition(xw, uaDataType.getEnumDefinition());
         xw.endElement();
         return;
@@ -909,9 +872,11 @@ function _dumpUADataTypeDefinition(xw: XmlWriter, uaDataType: UADataType) {
         const t = true;
         if (t || dataValue.statusCode.isGood()) {
             const definition = uaDataType.getStructureDefinition();
-            const baseDefinition = uaDataTypeBase ? uaDataTypeBase.getStructureDefinition() : null;
+            // a structure's supertype need not be a structure: `Structure` itself subtypes BaseDataType,
+            // which has no definition at all. Asking it for one threw, and took the whole export with it
+            const baseDefinition = uaDataTypeBase?.isStructure() ? uaDataTypeBase.getStructureDefinition() : null;
             xw.startElement("Definition");
-            xw.writeAttribute("Name", b(xw, uaDataType.browseName));
+            xw.writeAttribute("Name", definitionName);
             if (definition.structureType === StructureType.Union) {
                 xw.writeAttribute("IsUnion", "true");
             }
@@ -993,8 +958,14 @@ function dumpUAVariable(xw: XmlWriter, node: UAVariable) {
         // sub elements
         dumpCommonElements(xw, node);
 
-        const value = (node as UAVariableImpl).$dataValue.value;
-        if (value) {
+        // a value the loader made up for a variable the document left unvalued is not written
+        // back out; see valueWasSynthesized in nodeset_record_applier. What used to stand here was
+        // _isDefaultValue, which dropped every zero and every empty string alike -- suppressing the
+        // made-up ones at the cost of the ones the document really did declare
+        const synthesized = (node as unknown as { valueWasSynthesized?: boolean }).valueWasSynthesized;
+        const dataValue = (node as UAVariableImpl).$dataValue;
+        const value = dataValue.value;
+        if (value && !synthesized && !dataValue.statusCode.equals(StatusCodes.BadWaitingForInitialData)) {
             _dumpValue(xw, node, value);
         }
     }
@@ -1236,10 +1207,6 @@ BaseNodeImpl.prototype.dumpXML = function (this: BaseNodeImpl, xw: XmlWriter) {
     writeWalkEvents(xw, this.addressSpace, translationTable, events);
 };
 
-export function makeTypeXsd(namespaceUri: string): string {
-    return `${namespaceUri.replace(/\/$/, "")}/Type.xsd`;
-}
-
 NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
     const namespaceArrayNode = this.addressSpace.findNode(VariableIds.Server_NamespaceArray);
     const namespaceArray: string[] = namespaceArrayNode

package/impl/ua_data_type_impl.ts

@@ -52,6 +52,10 @@ export interface EnumerationInfo {
 export interface UADataTypeOptions extends InternalBaseNodeOptions {
     partialDefinition: StructureFieldOptions[] | EnumFieldOptions[];
     isUnion?: boolean;
+    /** the DataType is a bit mask, not an enumeration; see UADataTypeImpl.isOptionSet */
+    isOptionSet?: boolean;
+    /** the <Definition> Name as declared; see UADataTypeImpl.declaredDefinitionName */
+    definitionName?: string;
     isAbstract?: boolean;
     symbolicName?: string;
 }
@@ -94,11 +98,37 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
     private $partialDefinition?: StructureFieldOptionsEx[] | EnumFieldOptions[];
     private $fullDefinition?: StructureDefinition | EnumDefinition;
 
+    /**
+     * whether the nodeset declared this DataType with `IsOptionSet="true"`: a bit mask whose fields
+     * are bit positions rather than an enumeration whose fields are values. node-opcua builds no
+     * enumeration and no structure for one -- it is a plain UInt16 or UInt32 subtype -- so without
+     * this flag and the fields kept in $partialDefinition, an OptionSet that goes into the address
+     * space cannot come out again as the DataType the document declared.
+     */
+    public isOptionSetDataType = false;
+
+    /**
+     * the Name attribute of the <Definition> element as the nodeset spelled it. The published
+     * catalogue uses both spellings -- 467 bare names and 211 namespace-prefixed ones -- so there
+     * is no form to normalise to: recomputing it from the browse name rewrote every bare one.
+     * Undefined for a DataType this address space built itself, which has no declaration to keep.
+     */
+    public declaredDefinitionName?: string;
+
+    /** the fields of the <Definition> as declared, for a DataType the address space models no further */
+    public get declaredDefinitionFields(): StructureFieldOptionsEx[] | EnumFieldOptions[] | undefined {
+        return this.$partialDefinition;
+    }
+
     constructor(options: UADataTypeOptions) {
         super(options);
         if (options.partialDefinition) {
             this.$partialDefinition = options.partialDefinition;
         }
+        this.isOptionSetDataType = !!options.isOptionSet;
+        if (options.definitionName) {
+            this.declaredDefinitionName = options.definitionName;
+        }
         this.isAbstract = options.isAbstract === undefined || options.isAbstract === null ? false : options.isAbstract;
         this.symbolicName = options.symbolicName || this.browseName.name || "";
     }
@@ -261,7 +291,12 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
     }
     getStructureDefinition(): StructureDefinition {
         const definition = this._getDefinition();
-        assert(definition instanceof StructureDefinition);
+        // named: a bare assert here threw an Error with an empty message, which told a caller
+        // nothing at all about which DataType had refused and what it had instead
+        assert(
+            definition instanceof StructureDefinition,
+            `${this.browseName.toString()} (${this.nodeId.toString()}) has no StructureDefinition: ${definition ? definition.constructor.name : "none"}`
+        );
         return definition as StructureDefinition;
     }
 
@@ -271,7 +306,10 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
     }
     getEnumDefinition(): EnumDefinition {
         const definition = this._getDefinition();
-        assert(definition instanceof EnumDefinition);
+        assert(
+            definition instanceof EnumDefinition,
+            `${this.browseName.toString()} (${this.nodeId.toString()}) has no EnumDefinition: ${definition ? definition.constructor.name : "none"}`
+        );
         return definition as EnumDefinition;
     }
 

package/impl/ua_object_type_impl.ts

@@ -4,12 +4,12 @@
 
 import type {
     AddObjectOptions,
+    AddReferenceOpts,
     BaseNodeEvents,
     InstantiateObjectOptions,
     ISessionContext,
     UAObject,
-    UAObjectType,
-    UAReference
+    UAObjectType
 } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { AttributeIds, type LocalizedTextLike, NodeClass } from "node-opcua-data-model";
@@ -28,11 +28,20 @@ import { assertUnusedChildBrowseName, topMostParentIsObjectTypeOrVariableType }
 
 export interface UAObjectTypeOptions extends InternalBaseNodeOptions {
     isAbstract?: boolean | null;
+    /** the EventNotifier the nodeset declared; see UAObjectTypeImpl.eventNotifier */
+    eventNotifier?: number;
 }
 
 export class UAObjectTypeImpl extends BaseNodeImpl<BaseNodeEvents> implements UAObjectType {
     public readonly nodeClass = NodeClass.ObjectType;
     public readonly isAbstract: boolean;
+    /**
+     * the EventNotifier the nodeset declared. The XSD allows it on a UAObjectType and nodesets use
+     * it, but nothing here held it: the attribute was dropped at load, and -- because the name was
+     * then free -- a child called EventNotifier claimed `eventNotifier` through the shared child
+     * accessors, so reading it handed back a BaseNode. PublishedEventsType is such a type.
+     */
+    public readonly eventNotifier: number;
     /**
      * returns true if the object has some opcua methods
      */
@@ -54,6 +63,7 @@ export class UAObjectTypeImpl extends BaseNodeImpl<BaseNodeEvents> implements UA
     constructor(options: UAObjectTypeOptions) {
         super(options);
         this.isAbstract = options.isAbstract ?? false;
+        this.eventNotifier = options.eventNotifier ?? 0;
     }
 
     public readAttribute(context: ISessionContext, attributeId: AttributeIds): DataValue {
@@ -118,7 +128,10 @@ export class UAObjectTypeImpl extends BaseNodeImpl<BaseNodeEvents> implements UA
         const baseObjectType = addressSpace.findObjectType("BaseObjectType") as UAObjectType;
         assert(baseObjectType, "BaseObjectType must be defined in the address space");
 
-        const references: UAReference[] = [];
+        // caller-supplied references (typically an inverse aggregate reference to a
+        // parent that has no dedicated option, e.g. HasOrderedComponent) are created
+        // with the node, so the NodeIdManager sees the parent when naming it.
+        const references: AddReferenceOpts[] = options.references ? [...options.references] : [];
 
         const copyAlsoModellingRules = topMostParentIsObjectTypeOrVariableType(addressSpace, options);
 

package/impl/ua_variable_impl.ts

@@ -283,8 +283,19 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
 
         this.historizing = !!options.historizing; // coerced to boolean"
 
-        // a Variant built from null takes the constructor's short path; the options form costs twice as much
-        this.$dataValue = new DataValue({ statusCode: StatusCodes.UncertainInitialValue, value: new Variant(null) });
+        // a Variant built from null takes the constructor's short path; the options form costs twice as much.
+        // Stamped with the clock of the construction: a variable nobody gives a value to (a nodeset
+        // Variable of an abstract data type has no default to make up) is read as it is, and the
+        // requested timestamps are expected on that Uncertain result too (FEAT-34)
+        const now = getCurrentClock();
+        this.$dataValue = new DataValue({
+            statusCode: StatusCodes.UncertainInitialValue,
+            value: new Variant(null),
+            sourceTimestamp: now.timestamp,
+            sourcePicoseconds: now.picoseconds,
+            serverTimestamp: now.timestamp,
+            serverPicoseconds: now.picoseconds
+        });
 
         if (options.value) {
             this.bindVariable(options.value);
@@ -405,23 +416,27 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             context = SessionContext.defaultContext;
         }
 
+        // A Bad result the variable makes up here carries the requested timestamps: a
+        // DataValue may carry them whatever its status, and the CTT expects them on every
+        // result of a Read with TimestampsToReturn Source or Both (Attribute Read 037 for
+        // the encoding, Base Info Core Structure 2 001 for the arguments of a method the
+        // nodeset reserves to a role nobody holds, FEAT-34). The clock of the denial is
+        // the honest source timestamp: the value behind it stays undisclosed.
         if (context.isAccessRestricted(this)) {
-            return new DataValue({ statusCode: StatusCodes.BadSecurityModeInsufficient });
+            return makeNowDataValue({ statusCode: StatusCodes.BadSecurityModeInsufficient });
         }
 
         if (!this.isReadable(context)) {
-            return new DataValue({ statusCode: StatusCodes.BadNotReadable });
+            return makeNowDataValue({ statusCode: StatusCodes.BadNotReadable });
         }
         if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
-            return new DataValue({ statusCode: StatusCodes.BadUserAccessDenied });
+            return makeNowDataValue({ statusCode: StatusCodes.BadUserAccessDenied });
         }
         if (!this.isUserReadable(context)) {
-            return new DataValue({ statusCode: StatusCodes.BadNotReadable });
+            return makeNowDataValue({ statusCode: StatusCodes.BadNotReadable });
         }
         if (!isValidDataEncoding(dataEncoding)) {
-            // Table 51: no encoding can be applied to a non-Structure value. The CTT
-            // (Attribute Read 037) still expects the requested timestamps on this Bad
-            // result, and a DataValue may carry them whatever its status.
+            // Table 51: no encoding can be applied to a non-Structure value
             return makeNowDataValue({ statusCode: StatusCodes.BadDataEncodingInvalid });
         }
 
@@ -1307,8 +1322,10 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
 
         let func: (innerCallback: (err: Error | null, dataValue: DataValue) => void) => void;
 
+        // stamped like the same gates of readValue(): the requested timestamps are expected
+        // on a Bad result too (FEAT-34)
         const answerStatusOnly = (statusCode: StatusCode) => (innerCallback: (err: Error | null, dataValue: DataValue) => void) =>
-            innerCallback(null, new DataValue({ statusCode }));
+            innerCallback(null, makeNowDataValue({ statusCode }));
 
         if (context.isAccessRestricted(this)) {
             // same gate as readValue(): a variable bound with a simple get()