node-opcua-address-space 2.183.0 → 2.184.0

package/impl/nodeid_manager.ts

@@ -51,11 +51,17 @@ function _filterAggregates(addressSpace: AddressSpacePartial, references: UARefe
     return [ref.nodeId, ""];
 }
 
+function _declaredParent(options: ConstructNodeIdOptions): NodeId | null {
+    const declared = options.parentNodeId;
+    if (!declared) return null;
+    if (declared instanceof BaseNodeImpl) return declared.nodeId;
+    const nodeId = resolveNodeId(declared as NodeIdLike);
+    return nodeId.isEmpty() ? null : nodeId;
+}
+
 function _findParentNodeId(addressSpace: AddressSpacePartial, options: ConstructNodeIdOptions): [NodeId, Suffix] | null {
-    if (!options.references) {
-        return null;
-    }
-    for (const ref of options.references) {
+    const references = options.references ?? [];
+    for (const ref of references) {
         const _ref = ref as ReferenceImpl;
         _ref._referenceType = addressSpace.findReferenceType(ref.referenceType) ?? undefined;
         /* c8 ignore next */
@@ -64,8 +70,19 @@ function _findParentNodeId(addressSpace: AddressSpacePartial, options: Construct
         }
         _ref.referenceType = _ref._referenceType.nodeId;
     }
+    // A declared parent names the node, whatever reference links the two, as it
+    // is the node's parent: an Organizes-only member of a type is
+    // `<Type>_MachineryBuildingBlocks` in the ModelCompiler's NodeIds.csv, and a
+    // node with two aggregating parents is named after the declared one.
+    const declared = _declaredParent(options);
+    if (declared) {
+        const viaEncoding = references.some(
+            (ref) => !ref.isForward && sameNodeId(ref.nodeId, declared) && sameNodeId(ref.referenceType, hasEncoding)
+        );
+        return [declared, viaEncoding ? "_Encoding" : ""];
+    }
     // find HasComponent, or has Property reverse
-    return _filterAggregates(addressSpace, options.references);
+    return references.length ? _filterAggregates(addressSpace, references) : null;
 }
 
 function prepareName(browseName?: QualifiedName | QualifiedNameOptions): string {
@@ -83,6 +100,11 @@ export interface ConstructNodeIdOptions {
     nodeClass?: NodeClass;
     references?: UAReference[];
     registerSymbolicNames?: boolean;
+    /**
+     * The declared parent (NodeSet `ParentNodeId`, or `parentNodeId` on the add* API).
+     * When present it names the node, as it is the node's parent (see `BaseNode.parent`).
+     */
+    parentNodeId?: NodeIdLike | BaseNode | null;
 }
 export type NodeEntry = [string, number, NodeClass];
 export type NodeEntry1 = [string, number, string /*"Object" | "Variable" etc...*/];
@@ -101,6 +123,19 @@ export class NodeIdManager {
         this.addressSpace = addressSpace;
     }
 
+    /**
+     * Put the id counter back where a fresh manager starts, so that a namespace emptied and
+     * populated again hands out the same generated ids as the first time.
+     *
+     * The symbolic name table is deliberately kept: it is the mapping the caller supplied (or
+     * that the first population established) between a name and the id that name must keep, and
+     * a recycled namespace has to honour it again. Nothing can clash with a retired id -
+     * `buildNewNodeId` skips both the ids in that table and any nodeId still registered.
+     */
+    public reset(): void {
+        this._internal_id_counter = 1000;
+    }
+
     public setSymbols(symbols: NodeEntry1[]): void {
         function convertNodeClass(nodeClass: string): NodeClass {
             return (NodeClass as unknown as Record<string, NodeClass>)[nodeClass];

package/impl/nodeset_tools/construct_namespace_dependency.ts

@@ -64,7 +64,7 @@ export function _recomputeRequiredModelsFromTypes(namespace: INamespace, cache?:
         if (_visitedDataType.has(dataType.toString())) {
             return;
         }
-        // c8 ignore next
+        /* c8 ignore next */
         if (dataTypeNode.nodeClass !== NodeClass.DataType) {
             warningLog("exploreDataTypes! ignoring ", dataTypeNode.toString());
             return;
@@ -87,12 +87,12 @@ export function _recomputeRequiredModelsFromTypes(namespace: INamespace, cache?:
         assert(!(e instanceof Variant));
         const nodeId = e.schema.encodingDefaultXml || e.schema.dataTypeNodeId || e.schema.dataTypeNodeId;
         consider(nodeId.namespace);
-        // c8 ignore next
+        /* c8 ignore next */
         if (e.schema.dataTypeNodeId.isEmpty()) {
             warningLog("Cannot find dataTypeNodeId for ", e.schema.name);
         }
         const d = addressSpace.findNode(e.schema.dataTypeNodeId) as UADataType | null;
-        // c8 ignore next
+        /* c8 ignore next */
         if (!d) return;
         exploreDataTypes(d);
     }
@@ -137,7 +137,7 @@ export function _recomputeRequiredModelsFromTypes(namespace: INamespace, cache?:
                 if (dataTypeNode) {
                     consider(dataTypeNode.nodeId.namespace);
                 } else {
-                    // c8 ignore next
+                    /* c8 ignore next */
                     if (dataTypeNodeId.value !== 0) {
                         warningLog("Warning: Cannot find dataType", dataTypeNodeId.toString());
                     }

package/impl/nodeset_tools/dump_to_bsd.ts

@@ -27,7 +27,7 @@ function buildXmlName(addressSpace: AddressSpacePrivate, map: Map<number, string
         return "ua:ExtensionObject";
     }
     const node = addressSpace.findNode(nodeId);
-    // c8 ignore next
+    /* c8 ignore next */
     if (!node) {
         throw new Error(`Cannot find Node for${nodeId?.toString()}`);
     }

package/impl/nodeset_tools/nodeset_to_xml.ts

@@ -104,7 +104,7 @@ function _hasHigherPriorityThan(xw: XmlWriter, namespaceIndex1: number, namespac
 
 function _mustFindReferenceType(addressSpace: IAddressSpace, name: string): UAReferenceType {
     const referenceType = addressSpace.findReferenceType(name);
-    // c8 ignore next
+    /* c8 ignore next */
     if (!referenceType) {
         throw new Error(`Cannot find standard reference type ${name}: please check your nodeset file`);
     }

package/impl/state_machine/finite_state_machine.ts

@@ -65,6 +65,50 @@ function getComponentOfType(typeDef: UAObjectType, typedefinition: UAObjectType)
     return components_parts as UAObject[];
 }
 
+/**
+ * OPC 10000-16 requires that a StateMachineType (or subtype) that raises events declares a
+ * GeneratesEvent reference to the EventType(s) it raises, on the type itself or on one of its
+ * super types (the CTT's "Base Info State Machine Instance / 001.js" script walks the instance's
+ * type up to StateMachineType looking for one such reference and accepts BaseEventType or any
+ * subtype as the target).
+ *
+ * node-opcua's finite state machine implementation always raises a "TransitionEventType" event
+ * when the current state changes (see FiniteStateMachineType#setState), for every state machine
+ * instance, whichever subtype of FiniteStateMachineType it is instantiated from. Declaring the
+ * reference once on FiniteStateMachineType therefore covers every state machine exposed by the
+ * server (ExclusiveLimitStateMachineType included), matching the CTT's parent walk.
+ *
+ * This is called from every state machine's _post_initialize, so it must be idempotent.
+ */
+function ensureFiniteStateMachineTypeGeneratesTransitionEvent(finiteStateMachineType: UAObjectType): void {
+    const addressSpace = finiteStateMachineType.addressSpace;
+
+    // Some minimal test fixtures load only a handful of namespace-0 nodes and do not carry the
+    // GeneratesEvent ReferenceType or TransitionEventType ObjectType at all: nothing to attach to.
+    if (!addressSpace.findReferenceType("GeneratesEvent")) {
+        return;
+    }
+    const transitionEventType = addressSpace.findObjectType("TransitionEventType");
+    if (!transitionEventType) {
+        /* c8 ignore next */
+        return;
+    }
+
+    const hasReferenceAlready = finiteStateMachineType
+        .findReferencesEx("GeneratesEvent", BrowseDirection.Forward)
+        .some((ref) => sameNodeId(ref.nodeId, transitionEventType.nodeId));
+
+    if (hasReferenceAlready) {
+        return;
+    }
+
+    finiteStateMachineType.addReference({
+        referenceType: "GeneratesEvent",
+        isForward: true,
+        nodeId: transitionEventType.nodeId
+    });
+}
+
 const defaultPredicate = (transitions: UATransition[], fromState: UAState, toState: UAState) => {
     if (transitions.length === 0) {
         return null;
@@ -88,13 +132,13 @@ export function getFiniteStateMachineTypeStates(uaFiniteStateMachineType: UAObje
     const addressSpace = uaFiniteStateMachineType.addressSpace;
 
     const initialStateType = addressSpace.findObjectType("InitialStateType");
-    // c8 ignore next
+    /* c8 ignore next */
     if (!initialStateType) {
         throw new Error("cannot find InitialStateType");
     }
 
     const stateType = addressSpace.findObjectType("StateType");
-    // c8 ignore next
+    /* c8 ignore next */
     if (!stateType) {
         throw new Error("cannot find StateType");
     }
@@ -109,7 +153,7 @@ export function getFiniteStateMachineTypeTransitions(uaFiniteStateMachineType: U
     const addressSpace = uaFiniteStateMachineType.addressSpace;
 
     const transitionType = addressSpace.findObjectType("TransitionType");
-    // c8 ignore next
+    /* c8 ignore next */
     if (!transitionType) {
         throw new Error("cannot find TransitionType");
     }
@@ -178,7 +222,7 @@ export class UAStateMachineImplBase extends UAObjectImpl implements UAStateMachi
         const typeDef = this.typeDefinitionObj;
 
         const comp = getComponentOfType(typeDef, initialStateType);
-        // c8 ignore next
+        /* c8 ignore next */
         if (comp.length > 1) {
             throw new Error(" More than 1 initial state in stateMachine");
         }
@@ -214,7 +258,7 @@ export class UAStateMachineImplBase extends UAObjectImpl implements UAStateMachi
         // to be executed there must be a transition from currentState to toState
         const transition = this.findTransitionNode(this.currentStateNode, toStateNode, predicate);
         if (!transition) {
-            // c8 ignore next
+            /* c8 ignore next */
             if (doDebug) {
                 debugLog(" No transition from ", this.currentStateNode.browseName.toString(), " to ", toStateNode.toString());
             }
@@ -242,18 +286,18 @@ export class UAStateMachineImplBase extends UAObjectImpl implements UAStateMachi
             return null;
         }
 
-        // c8 ignore next
+        /* c8 ignore next */
         if (_fromStateNode.nodeClass !== NodeClass.Object) {
             throw new Error("Internal Error");
         }
-        // c8 ignore next
+        /* c8 ignore next */
         if (_toStateNode && _toStateNode.nodeClass !== NodeClass.Object) {
             throw new Error("Internal Error");
         }
 
         const stateType = addressSpace.findObjectType("StateType");
 
-        // c8 ignore next
+        /* c8 ignore next */
         if (!stateType) {
             throw new Error("Cannot find StateType");
         }
@@ -270,7 +314,7 @@ export class UAStateMachineImplBase extends UAObjectImpl implements UAStateMachi
             // cannot find a transition from fromState to toState
             return null;
         }
-        // c8 ignore next
+        /* c8 ignore next */
         if (transitions.length > 1) {
             const selectedTransition = (predicate || defaultPredicate)(
                 transitions,
@@ -316,7 +360,7 @@ export class UAStateMachineImplBase extends UAObjectImpl implements UAStateMachi
 
         if (typeof toStateNode === "string") {
             const state = this.getStateByName(toStateNode);
-            // c8 ignore next
+            /* c8 ignore next */
             if (!state) {
                 throw new Error(`Cannot find state with name ${toStateNode}`);
             }
@@ -590,6 +634,8 @@ export class UAStateMachineImplBase extends UAObjectImpl implements UAStateMachi
             throw new Error("cannot find FiniteStateMachineType");
         }
 
+        ensureFiniteStateMachineTypeGeneratesTransitionEvent(finiteStateMachineType);
+
         // xx assert(this.typeDefinitionObj && !this.subtypeOfObj);
         // xx assert(!this.typeDefinitionObj || this.typeDefinitionObj.isSubtypeOf(finiteStateMachineType));
         // get current Status

package/impl/state_machine/ua_shelving_state_machine_ex.ts

@@ -159,7 +159,7 @@ function _automatically_unshelve(shelvingState: UAShelvedStateMachineExImpl) {
     assert(shelvingState._timer, "expecting timerId to be set");
     shelvingState._timer = null;
 
-    // c8 ignore next
+    /* c8 ignore next */
     if (doDebug) {
         debugLog("Automatically un-shelving variable ", shelvingState.browseName.toString());
     }

package/impl/state_machine/ua_two_state_variable.ts

@@ -153,7 +153,7 @@ export function promoteToTwoStateVariable(node: UAVariable): UATwoStateVariableE
     if (node instanceof UATwoStateVariableImpl) {
         return node;
     }
-    // c8 ignore next
+    /* c8 ignore next */
     if (!(node instanceof UAVariableImpl)) {
         throw new Error("Trying to promote a invalid object");
     }

package/impl/tool_isSubtypeOf.ts

@@ -49,7 +49,7 @@ function _slow_isSubtypeOf<T extends UAType>(this: T, Class: typeof BaseNodeImpl
     for (const subType1 of subTypes) {
         const subTypeId = subType1.nodeId;
         const subTypeNode = this.addressSpace.findNode(subTypeId) as unknown as T;
-        // c8 ignore next
+        /* c8 ignore next */
         if (!subTypeNode) {
             throw new Error(`Cannot find object with nodeId ${subTypeId.toString()}`);
         }

package/impl/ua_data_type_impl.ts

@@ -9,7 +9,7 @@ import { DataTypeIds } from "node-opcua-constants";
 import { AttributeIds, type LocalizedText, NodeClass, type QualifiedNameLike } from "node-opcua-data-model";
 import { DataValue, type DataValueLike } from "node-opcua-data-value";
 import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
-import { ExpandedNodeId, NodeId, resolveNodeId } from "node-opcua-nodeid";
+import { ExpandedNodeId, NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { NumericRange } from "node-opcua-numeric-range";
 import { StatusCodes } from "node-opcua-status-code";
 import {
@@ -323,10 +323,31 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
         const union = addressSpace.findDataType("Union");
 
         // we have a data type from a companion specification
-        // let's see if this data type need to be registered
-        const isEnumeration = enumeration && this.isSubtypeOf(enumeration);
-        const isStructure = structure && this.isSubtypeOf(structure);
-        const isUnion = !!(structure && union && this.isSubtypeOf(union));
+        // let's see if this data type need to be registered.
+        //
+        // One walk up the chain answers all three questions. `isSubtypeOf` would answer each of
+        // them, and memoizes — but its memo is keyed on a counter bumped every time a HasSubtype
+        // reference is added anywhere, so during a load, which adds thousands of them, the memo
+        // is thrown away before it is ever read and each call walks the chain from scratch. Three
+        // walks become one, and the one uses `subtypeOfObj`, which is cached per node, instead of
+        // filtering the node's whole reference list at every level.
+        let isEnumeration = false;
+        let isStructure = false;
+        let isUnion = false;
+        {
+            let ancestor: UADataTypeImpl | null = this;
+            // a chain longer than this is a cycle in a broken nodeset, not a model
+            let guard = 128;
+            while (ancestor && guard-- > 0) {
+                const nodeId = ancestor.nodeId;
+                if (enumeration && sameNodeId(nodeId, enumeration.nodeId)) isEnumeration = true;
+                if (structure && sameNodeId(nodeId, structure.nodeId)) isStructure = true;
+                if (union && sameNodeId(nodeId, union.nodeId)) isUnion = true;
+                ancestor = ancestor.subtypeOfObj as UADataTypeImpl | null;
+            }
+            // a Union is a Structure; the original asked for both and so does this
+            isUnion = isUnion && !!structure;
+        }
 
         const isRootDataType = (n: UADataType) => n.nodeId.namespace === 0 && n.nodeId.value === DataTypeIds.BaseDataType;
 

package/impl/ua_method_impl.ts

@@ -68,7 +68,10 @@ export class UAMethodImpl extends BaseNodeImpl<UAMethodEvents> implements UAMeth
     public methodDeclarationId: NodeId;
     public _getExecutableFlag?: (this: UAMethod, context: ISessionContext | null) => boolean;
 
-    public _asyncExecutionFunction?: MethodFunctor;
+    // always the callback form: bindMethod normalises the promise form before storing it. A union
+    // here would be wider than what can be held, and `.call` on a union of signatures does not
+    // resolve to the callback one.
+    public _asyncExecutionFunction?: MethodFunctorC;
 
     constructor(options: IMethodOptons) {
         super(options);
@@ -138,11 +141,12 @@ export class UAMethodImpl extends BaseNodeImpl<UAMethodEvents> implements UAMeth
 
     public bindMethod(async_func: MethodFunctor): void {
         assert(typeof async_func === "function");
-        if (async_func.length === 2) {
-            async_func = callbackify(async_func as MethodFunctorA) as MethodFunctorC;
-        }
-        assert(async_func.length === 3, ` a method with callback should have 3 arguments : got ${async_func.length}`);
-        this._asyncExecutionFunction = async_func;
+        const callbackForm: MethodFunctorC =
+            async_func.length === 2
+                ? (callbackify(async_func as MethodFunctorA) as MethodFunctorC)
+                : (async_func as MethodFunctorC);
+        assert(callbackForm.length === 3, ` a method with callback should have 3 arguments : got ${callbackForm.length}`);
+        this._asyncExecutionFunction = callbackForm;
     }
     public execute(
         object: UAObject | UAObjectType | null,

package/impl/ua_object_impl.ts

@@ -61,7 +61,7 @@ export class UAObjectImpl<T extends UAObjectEvents & ListenerSignature<T> = UAOb
     public readonly symbolicName: string | null;
 
     get typeDefinitionObj(): UAObjectType {
-        // c8 ignore next
+        /* c8 ignore next */
         if (super.typeDefinitionObj.nodeClass !== NodeClass.ObjectType) {
             const msg = `Invalid type definition node class , expecting a ObjectType got ${
                 NodeClass[super.typeDefinitionObj.nodeClass]
@@ -75,7 +75,11 @@ export class UAObjectImpl<T extends UAObjectEvents & ListenerSignature<T> = UAOb
     constructor(options: InternalBaseNodeOptions & { eventNotifier?: number; symbolicName?: string | null }) {
         super(options);
         this._eventNotifier = options.eventNotifier || EventNotifierFlags.None;
-        assert(typeof this.eventNotifier === "number" && isValidByte(this.eventNotifier));
+        // the declared flags, not the getter: reading the getter here scans the node's references
+        // for event sources and notifiers, twice, for a node that has just been built and whose
+        // references the loader has not wired yet. The getter answers the same value for a node in
+        // that state, and it still runs — and still caches — at the first real read.
+        assert(typeof this._eventNotifier === "number" && isValidByte(this._eventNotifier));
         this.symbolicName = options.symbolicName || null;
         // every event MonitoredItem on this object is one "event" listener, and the Server
         // object collects them for every Session: more than ten is the normal case, not a

package/impl/ua_object_type_impl.ts

@@ -147,6 +147,7 @@ export class UAObjectTypeImpl extends BaseNodeImpl<BaseNodeEvents> implements UA
             eventSourceOf: options.eventSourceOf,
             notifierOf: options.notifierOf,
             organizedBy: options.organizedBy,
+            parentNodeId: options.parentNodeId,
             addInOf: options.addInOf,
             references,
 

package/impl/ua_variable_impl.ts

@@ -83,8 +83,9 @@ import { SessionContext } from "../api/session_context.js";
 import { apply_condition_refresh, type ConditionRefreshCache } from "./apply_condition_refresh.js";
 import { BaseNodeImpl, type InternalBaseNodeOptions } from "./base_node_impl.js";
 import { _clone, ToStringBuilder, UAVariable_toString, valueRankToString } from "./base_node_private.js";
+import { loadClock } from "./bulk_load_clock.js";
 import { adjustDataValueStatusCode } from "./data_access/adjust_datavalue_status_code.js";
-import { notifySemanticsChangedIfNeeded } from "./data_access/semantics_changed.js";
+import { notifySemanticsChangedIfNeeded, raiseSemanticChangeEvent } from "./data_access/semantics_changed.js";
 import { _getBasicDataType } from "./get_basic_datatype.js";
 import { type EnumerationInfo, type IEnumItem, UADataTypeImpl } from "./ua_data_type_impl.js";
 import {
@@ -254,7 +255,7 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
     public __waiting_callbacks?: CallbackT<DataValue>[];
 
     get typeDefinitionObj(): UAVariableType {
-        // c8 ignore next
+        /* c8 ignore next */
         if (super.typeDefinitionObj && super.typeDefinitionObj.nodeClass !== NodeClass.VariableType) {
             // this could happen in faulty external nodeset and has been seen once
             // in an nano server
@@ -288,8 +289,10 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
         // 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();
+        // requested timestamps are expected on that Uncertain result too (FEAT-34).
+        // One reading for a whole load — see impl/bulk_load_clock.ts; outside a load of THIS
+        // address space this is getCurrentClock(), unchanged.
+        const now = loadClock(this.addressSpace);
         this.$dataValue = new DataValue({
             statusCode: StatusCodes.UncertainInitialValue,
             value: new Variant(null),
@@ -484,7 +487,7 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             dataValue.statusCode.equals(StatusCodes.BadWaitingForInitialData) ||
             dataValue.statusCode.equals(StatusCodes.UncertainInitialValue)
         ) {
-            // c8 ignore next
+            /* c8 ignore next */
             doDebug &&
                 debugLog(
                     chalk.red(" Warning:  UAVariable#readValue ") +
@@ -846,7 +849,8 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             if (variant1.dataType === DataType.ExtensionObject && !this.checkExtensionObjectIsCorrect(variant1.value)) {
                 throw new Error("invalid extension object");
             }
-            const now = getCurrentClock();
+            // the load's reading while this address space is being loaded, a fresh one otherwise
+            const now = loadClock(this.addressSpace);
             this.$dataValue = new DataValue({
                 value: variant1,
                 statusCode,
@@ -1883,13 +1887,13 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
 
         const addressSpace = this.addressSpace;
 
-        // c8 ignore next
+        /* c8 ignore next */
         if (!addressSpace) {
             warningLog("UAVariable#_internal_set_dataValue : no addressSpace ! may be node has already been deleted ?");
             return;
         }
 
-        // c8 ignore next
+        /* c8 ignore next */
         if (dataValue.value.arrayType === VariantArrayType.Matrix) {
             if (!dataValue.value.dimensions) {
                 throw new Error("missing dimensions: a Matrix Variant needs a dimension");
@@ -1997,6 +2001,9 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
     public handle_semantic_changed(_dataValue: DataValue): void {
         this.semantic_version = this.semantic_version + 1;
         (this as UAVariable).emit("semantic_changed");
+        // the bit tells whoever monitors this DataItem; the event tells whoever monitors the
+        // Server object (OPC 10000-5 6.4.31). Both have to come from this one place.
+        raiseSemanticChangeEvent(this as UAVariable);
     }
 
     private _readDataType(): DataValue {

package/impl/ua_variable_type_impl.ts

@@ -209,7 +209,7 @@ export class UAVariableTypeImpl extends BaseNodeImpl<BaseNodeEvents> implements
                     options.value = this.value as Variant;
                     options.statusCode = StatusCodes.Good;
                 } else {
-                    // c8 ignore next
+                    /* c8 ignore next */
                     doDebug && debugLog(" warning Value not implemented");
                     options.value = { dataType: DataType.Null };
                     options.statusCode = StatusCodes.BadAttributeIdInvalid;
@@ -277,7 +277,7 @@ export class UAVariableTypeImpl extends BaseNodeImpl<BaseNodeEvents> implements
         assertUnusedChildBrowseName(addressSpace, options);
 
         const baseVariableType = addressSpace.findVariableType("BaseVariableType");
-        // c8 ignore next
+        /* c8 ignore next */
         if (!baseVariableType) {
             throw new Error("BaseVariableType must be defined in the address space");
         }
@@ -298,7 +298,7 @@ export class UAVariableTypeImpl extends BaseNodeImpl<BaseNodeEvents> implements
 
         const arrayDimensions = options.arrayDimensions !== undefined ? options.arrayDimensions : this.arrayDimensions;
 
-        // c8 ignore next
+        /* c8 ignore next */
         if (!dataType || dataType.isEmpty()) {
             warningLog(" options.dataType", options.dataType ? options.dataType.toString() : "<null>");
             warningLog(" this.dataType", this.dataType ? this.dataType.toString() : "<null>");
@@ -331,6 +331,7 @@ export class UAVariableTypeImpl extends BaseNodeImpl<BaseNodeEvents> implements
             nodeId: options.nodeId,
             notifierOf: options.notifierOf,
             organizedBy: options.organizedBy,
+            parentNodeId: options.parentNodeId,
             // see InstantiateOptions.references: created with the node so the
             // NodeIdManager derives the symbolic name from that parent
             references: options.references,

package/nodeJS.d.ts

@@ -1 +1 @@
-export * from "./distNodeJS";
+export * from "./distNodeJS/index.js";

package/nodeJS.js

@@ -1 +1 @@
-module.exports = require("./distNodeJS");
+export * from "./distNodeJS/index.js";

package/package.json

@@ -1,6 +1,7 @@
 {
     "name": "node-opcua-address-space",
-    "version": "2.183.0",
+    "type": "module",
+    "version": "2.184.0",
     "description": "pure nodejs OPCUA SDK - module address-space",
     "main": "./dist/api/index.js",
     "types": "./dist/api/index.d.ts",
@@ -22,50 +23,50 @@
         "@types/semver": "7.8.0",
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
-        "node-opcua-address-space-base": "2.183.0",
-        "node-opcua-assert": "2.183.0",
-        "node-opcua-basic-types": "2.183.0",
-        "node-opcua-binary-stream": "2.183.0",
-        "node-opcua-client-dynamic-extension-object": "2.183.0",
-        "node-opcua-constants": "2.183.0",
+        "node-opcua-address-space-base": "2.184.0",
+        "node-opcua-assert": "2.184.0",
+        "node-opcua-basic-types": "2.184.0",
+        "node-opcua-binary-stream": "2.184.0",
+        "node-opcua-client-dynamic-extension-object": "2.184.0",
+        "node-opcua-constants": "2.184.0",
         "node-opcua-crypto": "5.10.1",
-        "node-opcua-data-access": "2.183.0",
-        "node-opcua-data-model": "2.183.0",
-        "node-opcua-data-value": "2.183.0",
-        "node-opcua-date-time": "2.183.0",
-        "node-opcua-debug": "2.183.0",
-        "node-opcua-enum": "2.183.0",
-        "node-opcua-extension-object": "2.183.0",
-        "node-opcua-factory": "2.183.0",
-        "node-opcua-nodeid": "2.183.0",
-        "node-opcua-nodeset-ua": "2.183.0",
-        "node-opcua-numeric-range": "2.183.0",
-        "node-opcua-object-registry": "2.183.0",
-        "node-opcua-pseudo-session": "2.183.0",
-        "node-opcua-service-browse": "2.183.0",
-        "node-opcua-service-call": "2.183.0",
-        "node-opcua-service-history": "2.183.0",
-        "node-opcua-service-translate-browse-path": "2.183.0",
-        "node-opcua-service-write": "2.183.0",
-        "node-opcua-status-code": "2.183.0",
-        "node-opcua-types": "2.183.0",
-        "node-opcua-utils": "2.183.0",
-        "node-opcua-variant": "2.183.0",
-        "node-opcua-xml2json": "2.183.0",
+        "node-opcua-data-access": "2.184.0",
+        "node-opcua-data-model": "2.184.0",
+        "node-opcua-data-value": "2.184.0",
+        "node-opcua-date-time": "2.184.0",
+        "node-opcua-debug": "2.184.0",
+        "node-opcua-enum": "2.184.0",
+        "node-opcua-extension-object": "2.184.0",
+        "node-opcua-factory": "2.184.0",
+        "node-opcua-nodeid": "2.184.0",
+        "node-opcua-nodeset-ua": "2.184.0",
+        "node-opcua-numeric-range": "2.184.0",
+        "node-opcua-object-registry": "2.184.0",
+        "node-opcua-pseudo-session": "2.184.0",
+        "node-opcua-service-browse": "2.184.0",
+        "node-opcua-service-call": "2.184.0",
+        "node-opcua-service-history": "2.184.0",
+        "node-opcua-service-translate-browse-path": "2.184.0",
+        "node-opcua-service-write": "2.184.0",
+        "node-opcua-status-code": "2.184.0",
+        "node-opcua-types": "2.184.0",
+        "node-opcua-utils": "2.184.0",
+        "node-opcua-variant": "2.184.0",
+        "node-opcua-xml2json": "2.184.0",
         "semver": "^7.8.5",
         "thenify-ex": "4.4.0",
         "xml-writer": "^1.7.0"
     },
     "devDependencies": {
         "humanize": "0.0.9",
-        "node-opcua-benchmarker": "2.183.0",
-        "node-opcua-leak-detector": "2.183.0",
-        "node-opcua-nodesets": "2.183.0",
-        "node-opcua-packet-analyzer": "2.183.0",
-        "node-opcua-schemas": "2.183.0",
-        "node-opcua-service-filter": "2.183.0",
-        "node-opcua-test-fixtures": "2.181.0",
-        "node-opcua-test-helpers": "2.183.0"
+        "node-opcua-benchmarker": "2.184.0",
+        "node-opcua-leak-detector": "2.184.0",
+        "node-opcua-nodesets": "2.184.0",
+        "node-opcua-packet-analyzer": "2.184.0",
+        "node-opcua-schemas": "2.184.0",
+        "node-opcua-service-filter": "2.184.0",
+        "node-opcua-test-fixtures": "2.184.0",
+        "node-opcua-test-helpers": "2.184.0"
     },
     "author": "Etienne Rossignon",
     "license": "MIT",
@@ -82,7 +83,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "d9a9af54d162f0fbb8d287e168aaeeda2d5c38b7",
+    "gitHead": "441a5c63e3a4202eb8de8597acac77a3a49248b7",
     "files": [
         "dist",
         "distHelpers",
@@ -98,7 +99,7 @@
         "bin"
     ],
     "bin": {
-        "opcua-nodeset-image": "bin/opcua-nodeset-image.js",
-        "opcua-nodeset-live": "bin/opcua-nodeset-live.js"
+        "opcua-nodeset-image": "bin/opcua-nodeset-image.cjs",
+        "opcua-nodeset-live": "bin/opcua-nodeset-live.cjs"
     }
 }