node-opcua-address-space 2.182.2 → 2.183.1

package/impl/alarms_and_conditions/ua_limit_alarm_impl.ts

@@ -203,7 +203,7 @@ export class UALimitAlarmImplBase extends UAAlarmConditionImplBase implements UA
         this.lowLowLimit.setValueFromSource({ dataType: DataType.Double, value });
     }
 
-    protected _onInputDataValueChange(dataValue: DataValue): void {
+    public onInputDataValueChange(dataValue: DataValue): void {
         assert(dataValue instanceof DataValue);
 
         if (dataValue.statusCode.equals(StatusCodes.BadWaitingForInitialData)) {
@@ -212,20 +212,37 @@ export class UALimitAlarmImplBase extends UAAlarmConditionImplBase implements UA
         }
         if (dataValue.statusCode.isNotGood() && !dataValue.statusCode.equals(StatusCodes.UncertainInitialValue)) {
             // genuinely bad status (not the initial uncertain state) → no specific limit state, alarm inactive
-            this._signalNewCondition(null, false, "Input node value is not good");
+            this.signalNewCondition(null, false, "Input node value is not good");
             return;
         }
         if (dataValue.value.dataType === DataType.Null) {
             // input not yet set → no specific limit state, alarm inactive
-            this._signalNewCondition(null, false, "Input node value is null");
+            this.signalNewCondition(null, false, "Input node value is null");
             return;
         }
         const value = dataValue.value.value;
+        // deliberately the deprecated name, for the same reason as _calculateConditionInfo:
+        // an old subclass that overrode `_setStateBasedOnInputValue` is still reached, and a
+        // new assignment of the published name is reached through the delegate below.
         this._setStateBasedOnInputValue(value);
     }
 
-    protected _setStateBasedOnInputValue(_value: number): void {
-        throw new Error("_setStateBasedOnInputValue must be overriden");
+    /**
+     * How the alarm turns a numeric input value into limit states. Assign to it to give a
+     * limit alarm a rule of its own.
+     *
+     * The base implementation throws: a bare LimitAlarmType has no limit states to set, so
+     * every concrete limit alarm type defines this.
+     */
+    public setStateBasedOnInputValue(_value: number): void {
+        throw new Error("setStateBasedOnInputValue must be overriden");
+    }
+
+    /**
+     * @deprecated assign {@link setStateBasedOnInputValue} instead; this delegates to it.
+     */
+    public _setStateBasedOnInputValue(value: number): void {
+        this.setStateBasedOnInputValue(value);
     }
 
     protected _watchLimits(): void {

package/impl/alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl.ts

@@ -61,14 +61,14 @@ export class UANonExclusiveDeviationAlarmImplBase
 
         return alarm;
     }
-    public _setStateBasedOnInputValue(value: number): void {
+    public setStateBasedOnInputValue(value: number): void {
         const setpointValue = this.getSetpointValue();
         if (setpointValue === null) {
             throw new Error("Cannot access setpoint Value");
         }
         assert(Number.isFinite(setpointValue), "expecting a valid setpoint value");
         // call base class implementation
-        super._setStateBasedOnInputValue(value - setpointValue);
+        super.setStateBasedOnInputValue(value - setpointValue);
     }
 
     public getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined {
@@ -79,10 +79,21 @@ export class UANonExclusiveDeviationAlarmImplBase
         return DeviationAlarmHelper_getSetpointValue.call(this);
     }
 
-    public _onSetpointDataValueChange(dataValue: DataValue): void {
+    /**
+     * What the alarm does when the value of its setpoint node changes: re-evaluate the state
+     * of the alarm against the new setpoint, since the deviation it watches has just moved.
+     */
+    public onSetpointDataValueChange(dataValue: DataValue): void {
         DeviationAlarmHelper_onSetpointDataValueChange.call(this, dataValue);
     }
 
+    /**
+     * @deprecated assign {@link onSetpointDataValueChange} instead; this delegates to it.
+     */
+    public _onSetpointDataValueChange(dataValue: DataValue): void {
+        this.onSetpointDataValueChange(dataValue);
+    }
+
     public _install_setpoint(options: InstallSetPointOptions): void {
         DeviationAlarmHelper_install_setpoint.call(this, options);
     }

package/impl/alarms_and_conditions/ua_non_exclusive_limit_alarm_impl.ts

@@ -180,9 +180,9 @@ export class UANonExclusiveLimitAlarmImplBase extends UALimitAlarmImpl implement
 
         state_str = JSON.stringify(states);
 
-        UALimitAlarmImpl.prototype._signalNewCondition.call(this, state_str, isActive, value);
+        UALimitAlarmImpl.prototype.signalNewCondition.call(this, state_str, isActive, value);
     }
-    protected _setStateBasedOnInputValue(value: number): void {
+    public setStateBasedOnInputValue(value: number): void {
         assert(Number.isFinite(value), "expecting a valid value here");
 
         let isActive = false;

package/impl/alarms_and_conditions/ua_off_normal_alarm_impl.ts

@@ -168,7 +168,7 @@ export class UAOffNormalAlarmImplBase extends UADiscreteAlarmImplBase implements
         }
         const stateName = isActive ? "Active" : "Inactive";
         // also raise the event
-        this._signalNewCondition(stateName, isActive, message);
+        this.signalNewCondition(stateName, isActive, message);
         if (!isActive) {
             this.currentBranch().setRetain(false);
         }
@@ -183,7 +183,7 @@ export class UAOffNormalAlarmImplBase extends UADiscreteAlarmImplBase implements
         this.updateAlarmState(isActive, "automatique update");
     }
 
-    protected _onInputDataValueChange(dataValue: DataValue): void {
+    public onInputDataValueChange(dataValue: DataValue): void {
         if (dataValue.statusCode.isNotGood()) {
             // what shall we do ?
             return;

package/impl/base_node_impl.ts

@@ -165,6 +165,8 @@ export interface InternalBaseNodeOptions {
     browseName: QualifiedName;
     nodeId: NodeId;
     references?: UAReference[];
+    /** the parent the document declared (ParentNodeId), see CreateNodeOptions.parentNodeId */
+    parentNodeId?: NodeIdLike | BaseNode | null;
 
     displayName?: LocalizedTextLike | LocalizedTextLike[];
     description?: LocalizedTextLike | null;
@@ -443,6 +445,14 @@ export abstract class BaseNodeImpl<T extends BaseNodeEvents & ListenerSignature<
         if (options.releaseStatus) {
             this.releaseStatus = options.releaseStatus;
         }
+        if (options.parentNodeId) {
+            _private._declaredParentNodeId =
+                options.parentNodeId instanceof NodeId
+                    ? options.parentNodeId
+                    : (options.parentNodeId as BaseNode).nodeId instanceof NodeId
+                      ? (options.parentNodeId as BaseNode).nodeId
+                      : resolveNodeId(options.parentNodeId as NodeIdLike);
+        }
         if (options.declaredAccessRestrictions !== undefined) {
             this.declaredAccessRestrictions = options.declaredAccessRestrictions;
         }
@@ -1736,6 +1746,27 @@ function _setup_parent_item(this: BaseNode, referencesMap: Map<ReferenceKey, UAR
     const addressSpace = this.addressSpace;
 
     if (referencesMap.size > 0) {
+        // the document declared a parent (ParentNodeId): it wins when it is one of the
+        // hierarchical parents, whatever the order the references were declared in, and
+        // even through Organizes, which is otherwise not a parent relation. OPC Foundation
+        // NodeSets rely on it for a node reached from two parents (an add-in re-exposed
+        // from a folder) and for a folder a type organizes, and name ids after it.
+        const declared = _private._declaredParentNodeId;
+        if (declared) {
+            const hierarchical = this.findReferencesEx("HierarchicalReferences", BrowseDirection.Inverse);
+            const match = hierarchical.find((r) => sameNodeId(r.nodeId, declared));
+            if (match) {
+                return ReferenceImpl.resolveReferenceNode(addressSpace, match);
+            }
+            // the parent may be asked for while the document is still being loaded, before
+            // the other end of the reference has been declared: the document still says
+            // who the parent is
+            const declaredNode = addressSpace.findNode(declared);
+            if (declaredNode) {
+                return declaredNode;
+            }
+        }
+
         references = this.findReferencesEx("Aggregates", BrowseDirection.Inverse);
 
         if (references.length >= 1) {

package/impl/base_node_private.ts

@@ -112,6 +112,8 @@ interface BaseNodeCache {
     _displayName?: LocalizedText[];
     _displayNameRaw?: LocalizedTextLike | LocalizedTextLike[];
     _parent?: BaseNode | null;
+    /** the parent the document declared (`ParentNodeId`); consulted once, when _parent is first computed */
+    _declaredParentNodeId?: NodeId;
     /**
      * the references other nodes hold to this one; `EMPTY_REFERENCE_INDEX` until the first one
      * arrives, since a nodeset declares most references from both ends and most nodes never get one

package/impl/data_access/adjust_datavalue_status_code.ts

@@ -7,18 +7,47 @@ import { NodeClass } from "node-opcua-data-model";
 import type { DataValue } from "node-opcua-data-value";
 import { type StatusCode, StatusCodes } from "node-opcua-status-code";
 import type { Range } from "node-opcua-types";
-import type { Variant } from "node-opcua-variant";
-import type { UAVariableImpl } from "../ua_variable_impl.js";
+import { type Variant, VariantArrayType } from "node-opcua-variant";
 
-function validate_value_range(range: Range, variant: Variant) {
-    if (variant.value < range.low || variant.value > range.high) {
-        return false;
+function isOutOfRange(value: number, range: Range): boolean {
+    return value < range.low || value > range.high;
+}
+
+/**
+ * Checks that the value(s) carried by `variant` fall within `range`.
+ *
+ * `variant.value` is a plain number for a scalar write, but for an array (or matrix)
+ * variable it is an array-like (Array or a TypedArray) holding only the elements this
+ * particular Write touches - a client writing with an IndexRange sends just the sub-range
+ * it targets, so an out-of-range element elsewhere in the variable's full value (one this
+ * write leaves untouched) must never be seen here and must never fail the write. Comparing
+ * an array directly with `<`/`>` coerces it through Array.prototype.toString first: a
+ * one-element array happens to stringify to its bare element and compares correctly by
+ * accident, but any other length stringifies to a comma-joined list that parses to NaN,
+ * so every such comparison is silently false and a genuinely out-of-range multi-element
+ * write was never being rejected. Each element is compared numerically instead.
+ */
+function validate_value_range(range: Range, variant: Variant): boolean {
+    const value = variant.value;
+    if (variant.arrayType === VariantArrayType.Array || variant.arrayType === VariantArrayType.Matrix) {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        const length = (value as ArrayLike<number>).length;
+        for (let i = 0; i < length; i++) {
+            if (isOutOfRange((value as ArrayLike<number>)[i], range)) {
+                return false;
+            }
+        }
+        return true;
     }
-    return true;
+    return !isOutOfRange(value as number, range);
 }
 
 export function adjustDataValueStatusCode(
-    variable: UAVariableImpl,
+    // the public interface, not UAVariableImpl: this function is exported from api/, and the
+    // body only reads a child node, so naming an internal type here leaked it into the API
+    variable: UAVariable,
     dataValue: DataValue,
     acceptValueOutOfRange: boolean
 ): StatusCode {

package/impl/data_access/semantics_changed.ts

@@ -0,0 +1,102 @@
+/**
+ * @module node-opcua-address-space
+ *
+ * OPC 10000-8 (Data Access) 5.2: some Properties of a DataItem carry the *meaning* of its
+ * value rather than the value itself. When one of them changes, a client that has cached the
+ * old meaning would misinterpret every subsequent value, so the Server has to say so: the
+ * next data change notification of the DataItem carries the SemanticsChanged bit of
+ * OPC 10000-4 7.39.
+ *
+ * The address space side of that is `UAVariable#handle_semantic_changed()`, which bumps
+ * `semantic_version`; the MonitoredItem watches that counter. What was missing is the wiring
+ * between a Property and its DataItem: the `addAnalogDataItem` / `addTwoStateDiscrete` /
+ * `addMultiStateDiscrete` helpers each attached a "value_changed" listener by hand, so only a
+ * node built through one of those helpers was covered. A DataItem instantiated from its
+ * VariableType, loaded from a NodeSet, or assembled property by property (which is the only
+ * way to build the ArrayItemType subtypes) had none, and its EURange could be written without
+ * any notification ever carrying the bit.
+ *
+ * So the relation is resolved from the Property instead, at the moment its value changes:
+ * a Property named after one of the semantics-bearing Properties below, whose parent is a
+ * DataItem, notifies that parent. That covers every way a DataItem can come into existence,
+ * and needs no bookkeeping at construction time - which is what defeated a creation-time hook,
+ * since a hand-built DataItem gets its Properties *after* the Variable itself.
+ */
+import type { UAVariable, UAVariableType } from "node-opcua-address-space-base";
+import { VariableTypeIds } from "node-opcua-constants";
+import { NodeClass } from "node-opcua-data-model";
+import { resolveNodeId } from "node-opcua-nodeid";
+
+/**
+ * the Properties whose value carries the semantics of the DataItem they belong to.
+ *
+ * DataItemType             : Definition, ValuePrecision
+ * AnalogItemType/UnitType  : EURange, InstrumentRange, EngineeringUnits
+ * ArrayItemType (+subtypes): Title, AxisScaleType, XAxisDefinition, YAxisDefinition, ZAxisDefinition
+ * TwoStateDiscreteType     : TrueState, FalseState
+ * MultiStateDiscreteType   : EnumStrings
+ * MultiStateValueDiscrete  : EnumValues
+ */
+const semanticsBearingProperties = new Set<string>([
+    "AxisScaleType",
+    "Definition",
+    "EngineeringUnits",
+    "EURange",
+    "EnumStrings",
+    "EnumValues",
+    "FalseState",
+    "InstrumentRange",
+    "Title",
+    "TrueState",
+    "ValuePrecision",
+    "XAxisDefinition",
+    "YAxisDefinition",
+    "ZAxisDefinition"
+]);
+
+const dataItemTypeNodeId = resolveNodeId(VariableTypeIds.DataItemType);
+
+/**
+ * the DataItem whose semantics `property` carries, or null when `property` is not one of them.
+ *
+ * A positive answer is memoized on the Property; a negative one is not, because the name test
+ * that gates the lookup is a single Set hit and because a Property can be attached to its
+ * DataItem after its first value change.
+ */
+function semanticsOwnerOf(property: UAVariable): UAVariable | null {
+    const name = property.browseName.name;
+    if (!name || !semanticsBearingProperties.has(name)) {
+        return null;
+    }
+    const cache = property as UAVariable & { $$semanticsOwner?: UAVariable };
+    if (cache.$$semanticsOwner) {
+        return cache.$$semanticsOwner;
+    }
+    const parent = property.parent;
+    if (!parent || parent.nodeClass !== NodeClass.Variable) {
+        return null;
+    }
+    const dataItem = parent as UAVariable;
+    const typeDefinition = dataItem.typeDefinitionObj;
+    if (!typeDefinition || typeDefinition.nodeClass !== NodeClass.VariableType) {
+        return null;
+    }
+    const dataItemType = dataItem.addressSpace.findNode(dataItemTypeNodeId) as UAVariableType | null;
+    if (!dataItemType || !typeDefinition.isSubtypeOf(dataItemType)) {
+        return null;
+    }
+    cache.$$semanticsOwner = dataItem;
+    return dataItem;
+}
+
+/**
+ * called whenever a Variable's value really changed: if that Variable is a semantics-bearing
+ * Property of a DataItem, the DataItem's semantic_version is bumped so that the next data
+ * change notification of the DataItem carries the SemanticsChanged bit.
+ */
+export function notifySemanticsChangedIfNeeded(property: UAVariable): void {
+    const dataItem = semanticsOwnerOf(property);
+    if (dataItem) {
+        (dataItem as UAVariable & { handle_semantic_changed: (dataValue?: unknown) => void }).handle_semantic_changed();
+    }
+}

package/impl/data_access/ua_multistate_discrete_impl.ts

@@ -128,8 +128,6 @@ export function promoteToMultiStateDiscrete<T, DT extends DataType>(node: UAVari
     _node._post_initialize();
 
     assert(_node.enumStrings.browseName.toString() === "EnumStrings");
-    const handler = _node.handle_semantic_changed.bind(_node);
-    _node.enumStrings.on("value_changed", handler);
     _node.install_extra_properties();
     return node as UAMultiStateDiscreteImpl<T, DT>;
 }

package/impl/data_access/ua_two_state_discrete_impl.ts

@@ -32,13 +32,10 @@ export class UATwoStateDiscreteImplBase extends UAVariableImplT<boolean, DataTyp
     _post_initialize(): void {
         // The StatusCode SemanticsChanged bit shall be set if any of the FalseState or TrueState
         // (changes can cause misinterpretation by users or (scripting) programs) Properties are changed
-        // (see section 5.2 for additional information).
-        const handler = this.handle_semantic_changed.bind(this);
-
+        // (see section 5.2 for additional information). That is done generically in
+        // impl/data_access/semantics_changed.ts; all this has to do is warn about a missing Property.
         const falseState = this.getPropertyByName("FalseState");
-        if (falseState) {
-            falseState.on("value_changed", handler);
-        } else {
+        if (!falseState) {
             /* c8 ignore next */
             console.warn(
                 "warning: UATwoStateDiscrete -> a FalseState property is mandatory ",
@@ -47,9 +44,7 @@ export class UATwoStateDiscreteImplBase extends UAVariableImplT<boolean, DataTyp
             );
         }
         const trueState = this.getPropertyByName("TrueState");
-        if (trueState) {
-            trueState.on("value_changed", handler);
-        } else {
+        if (!trueState) {
             /* c8 ignore next */
             console.warn(
                 "waring: UATwoStateDiscrete -> a TrueState property is mandatory",
@@ -154,11 +149,10 @@ export function _addTwoStateDiscrete(namespace: INamespace, options: AddTwoState
     const dataValueVerif = variable.readValue();
     assert(dataValueVerif.value.dataType === DataType.Boolean);
     */
-    const handler = (variable as UAVariableImpl).handle_semantic_changed.bind(variable);
 
     add_dataItem_stuff(variable, options);
 
-    const trueStateNode = namespace.addVariable({
+    namespace.addVariable({
         browseName: { name: "TrueState", namespaceIndex: 0 },
         dataType: "LocalizedText",
         minimumSamplingInterval: 0,
@@ -171,9 +165,7 @@ export function _addTwoStateDiscrete(namespace: INamespace, options: AddTwoState
         })
     });
 
-    trueStateNode.on("value_changed", handler);
-
-    const falseStateNode = namespace.addVariable({
+    namespace.addVariable({
         browseName: { name: "FalseState", namespaceIndex: 0 },
         dataType: "LocalizedText",
         minimumSamplingInterval: 0,
@@ -187,8 +179,6 @@ export function _addTwoStateDiscrete(namespace: INamespace, options: AddTwoState
         })
     });
 
-    falseStateNode.on("value_changed", handler);
-
     variable.install_extra_properties();
 
     return promoteToTwoStateDiscrete(variable);

package/impl/historical_access/read_processed_details_hook.ts

@@ -0,0 +1,35 @@
+/**
+ * The supported way to plug a ReadProcessedDetails implementation into an address space.
+ *
+ * The aggregate functions live in node-opcua-aggregates, and the address space calls into them
+ * when a client issues a ReadProcessed history request, so the two packages need a hook between
+ * them. It used to be installed by casting the address space to AddressSpacePrivate and
+ * assigning to `_readProcessedDetails` from outside, which made an underscore-prefixed field
+ * part of another package's build in all but name.
+ */
+import type { ContinuationData, IAddressSpace, ISessionContext, UAVariable } from "node-opcua-address-space-base";
+import type { QualifiedNameLike } from "node-opcua-data-model";
+import type { NumericRange } from "node-opcua-numeric-range";
+import type { CallbackT } from "node-opcua-status-code";
+import type { HistoryReadResult, ReadProcessedDetails } from "node-opcua-types";
+import type { AddressSpacePrivate } from "../address_space_private.js";
+
+/** answers a ReadProcessed history request for one variable */
+export type ReadProcessedDetailsFunc = (
+    variable: UAVariable,
+    context: ISessionContext,
+    historyReadDetails: ReadProcessedDetails,
+    indexRange: NumericRange | null,
+    dataEncoding: QualifiedNameLike | null,
+    continuationData: ContinuationData,
+    callback: CallbackT<HistoryReadResult>
+) => void;
+
+/**
+ * Install the handler an address space calls for ReadProcessed history requests.
+ *
+ * Without one, a ReadProcessed request answers BadHistoryOperationUnsupported.
+ */
+export function installReadProcessedDetails(addressSpace: IAddressSpace, handler: ReadProcessedDetailsFunc): void {
+    (addressSpace as AddressSpacePrivate)._readProcessedDetails = handler;
+}

package/impl/namespace_impl.ts

@@ -1036,8 +1036,8 @@ export class NamespaceImpl implements NamespacePrivate {
 
         assert(euRange.readValue().value.value instanceof Range);
 
-        const handler = variable.handle_semantic_changed.bind(variable);
-        euRange.on("value_changed", handler);
+        // the SemanticsChanged wiring of EURange/InstrumentRange/EngineeringUnits is generic and
+        // lives in impl/data_access/semantics_changed.ts: it covers DataItems built any other way too.
 
         if (Object.hasOwn(options, "instrumentRange")) {
             const instrumentRangeExisting = variable.getPropertyByName("InstrumentRange") as UAVariableImpl | null;
@@ -1062,8 +1062,6 @@ export class NamespaceImpl implements NamespacePrivate {
                     StatusCodes.Good
                 );
             }
-
-            instrumentRange.on("value_changed", handler);
         }
         (variable as unknown as { acceptValueOutOfRange?: boolean }).acceptValueOutOfRange = options.acceptValueOutOfRange;
 
@@ -1096,8 +1094,6 @@ export class NamespaceImpl implements NamespacePrivate {
                     StatusCodes.Good
                 );
             }
-
-            eu.on("value_changed", handler);
         }
 
         variable.install_extra_properties();

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...*/];

package/impl/ua_object_impl.ts

@@ -77,6 +77,10 @@ export class UAObjectImpl<T extends UAObjectEvents & ListenerSignature<T> = UAOb
         this._eventNotifier = options.eventNotifier || EventNotifierFlags.None;
         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
+        // leak for Node to warn about (UAVariableImpl does the same for its "value_changed")
+        this.setMaxListeners(5000);
     }
 
     public readAttribute(
@@ -275,4 +279,12 @@ export class UAObjectImpl<T extends UAObjectEvents & ListenerSignature<T> = UAOb
     }
 }
 
-const plainChalk = new Proxy(chalk, { get: () => (s: string) => s }) as typeof chalk;
+// A colourless chalk for `inspect(node, { colors: false })`. Not a Proxy over `chalk`
+// returning the identity for every property: chalk 4 defines each style (`cyan`, ...)
+// on first use as a non-writable, non-configurable own data property, after which a
+// Proxy `get` trap returning anything else violates the Proxy invariant and throws a
+// TypeError. Node's own `warnMaxListenersExceeded` inspects the emitter without
+// colours, so that TypeError surfaced inside `node.on("event", ...)` when an eleventh
+// event MonitoredItem was created on the Server object, and killed the server process
+// (CTT A and C Refresh Err_004).
+const plainChalk = new chalk.Instance({ level: 0 });

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

@@ -84,6 +84,7 @@ import { apply_condition_refresh, type ConditionRefreshCache } from "./apply_con
 import { BaseNodeImpl, type InternalBaseNodeOptions } from "./base_node_impl.js";
 import { _clone, ToStringBuilder, UAVariable_toString, valueRankToString } from "./base_node_private.js";
 import { adjustDataValueStatusCode } from "./data_access/adjust_datavalue_status_code.js";
+import { notifySemanticsChangedIfNeeded } 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 {
@@ -104,7 +105,8 @@ const warningLog = make_warningLog("ua_variable_impl");
 const doDebug = checkDebugFlag("ua_variable_impl");
 const errorLog = make_errorLog("ua_variable_impl");
 
-const plainChalk = new Proxy(chalk, { get: () => (s: string) => s }) as typeof chalk;
+// a colourless chalk; see ua_object_impl.ts for why it is not a Proxy over `chalk`
+const plainChalk = new chalk.Instance({ level: 0 });
 
 export function adjust_accessLevel(accessLevel: string | number | AccessLevelFlag | null | undefined): AccessLevelFlag {
     const flag = makeAccessLevelFlag(accessLevel ?? "CurrentRead | CurrentWrite");
@@ -1963,6 +1965,15 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
         }
 
         if (!sameDataValue(old_dataValue, dataValue)) {
+            // a Property that carries the semantics of a DataItem (EURange, TrueState, ...) has to make
+            // the DataItem's next notification carry the SemanticsChanged bit. Done from the Property
+            // rather than with a listener installed when the DataItem is built, because a hand-built
+            // DataItem gets its Properties after itself - see impl/data_access/semantics_changed.ts.
+            // ... but a Property receiving its first value is a Variable being built, not a
+            // semantics change: until then its StatusCode is UncertainInitialValue.
+            if (old_dataValue.statusCode.isGood()) {
+                notifySemanticsChangedIfNeeded(this as UAVariable);
+            }
             if (this.getBasicDataType() === DataType.ExtensionObject) {
                 const preciseClock = coerceClock(this.$dataValue.sourceTimestamp, this.$dataValue.sourcePicoseconds);
                 const cache: Set<UAVariable> = new Set();

package/impl/ua_variable_type_impl.ts

@@ -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,