node-opcua-address-space 2.183.0 → 2.184.0

package/impl/address_space.ts

@@ -194,6 +194,20 @@ export class AddressSpaceImpl implements AddressSpacePrivate {
     public suspendBackReference = false;
     public isFrugal = false;
 
+    /**
+     * Stop collecting GeneralModelChangeEventType material.
+     *
+     * Every node added, deleted or re-referenced pays a probe - an inverse reference scan and a
+     * `getNodeVersion` per hierarchical parent - before the bookkeeping can conclude that no node
+     * involved carries a NodeVersion and there is nothing to report. A loader, a compiler or a
+     * test fixture has no subscriber for those events, so the probe is pure cost.
+     *
+     * Defaults to `false`, which is the behaviour every existing caller has. While it is `true`
+     * no ModelChangeStructure is collected and no NodeVersion is bumped, so set it only when
+     * nothing is listening - typically around a bulk load or a bulk delete.
+     */
+    public suspendModelChangeEvents = false;
+
     public registerChildAccessorNames(browseNames: string[]): void {
         defineSharedChildAccessors(browseNames);
     }
@@ -216,6 +230,8 @@ export class AddressSpaceImpl implements AddressSpacePrivate {
     public readonly isNodeIdString = isNodeIdString;
     private readonly _private_namespaceIndex: number;
     private readonly _namespaceArray: NamespacePrivate[];
+    /** uri -> index into `_namespaceArray`; registering and resolving a uri were linear scans */
+    private readonly _namespaceIndexByUri = new Map<string, number>();
     private _shutdownTask?: ShutdownTask[];
     private _eventIdCounter?: Buffer;
     public $$extraDataTypeManager?: ExtraDataTypeManager;
@@ -301,7 +317,8 @@ export class AddressSpaceImpl implements AddressSpacePrivate {
      */
     public getNamespaceIndex(namespaceUri: string): number {
         assert(typeof namespaceUri === "string");
-        return this._namespaceArray.findIndex((ns: NamespacePrivate) => ns.namespaceUri === namespaceUri);
+        const index = this._namespaceIndexByUri.get(namespaceUri);
+        return index === undefined ? -1 : index;
     }
 
     /**
@@ -314,12 +331,12 @@ export class AddressSpaceImpl implements AddressSpacePrivate {
      * @returns {Namespace}
      */
     public registerNamespace(namespaceUri: string): NamespacePrivate {
-        let index = this._namespaceArray.findIndex((ns) => ns.namespaceUri === namespaceUri);
-        if (index !== -1) {
-            assert(this._namespaceArray[index].addressSpace === this);
-            return this._namespaceArray[index];
+        const existing = this._namespaceIndexByUri.get(namespaceUri);
+        if (existing !== undefined) {
+            assert(this._namespaceArray[existing].addressSpace === this);
+            return this._namespaceArray[existing];
         }
-        index = this._namespaceArray.length;
+        const index = this._namespaceArray.length;
         this._namespaceArray.push(
             new NamespaceImpl({
                 addressSpace: this,
@@ -329,9 +346,61 @@ export class AddressSpaceImpl implements AddressSpacePrivate {
                 version: "undefined"
             })
         );
+        this._namespaceIndexByUri.set(namespaceUri, index);
         return this._namespaceArray[index];
     }
 
+    /**
+     * Empty a namespace, leaving the rest of the address space as it was before that namespace
+     * was ever populated, and the namespace itself registered under the same index and uri and
+     * ready to be populated again.
+     *
+     * This is the recycle that lets a compiler keep its loaded base nodesets across an edit:
+     * rebuilding the model's own namespace costs a fraction of rebuilding the whole address
+     * space. Everything goes in one model-change transaction, and only the references that cross
+     * the namespace boundary are severed - the ones inside it die with their nodes.
+     *
+     * It lives here rather than on Namespace because most of what it touches is not the
+     * namespace's: references held by nodes of other namespaces, the DataType factory this
+     * namespace registered with the address space's DataType manager, the address space's set of
+     * historizing nodes.
+     *
+     * Namespace 0 cannot be deleted: it is the standard namespace every other node resolves
+     * against.
+     *
+     * A structure DataType of the namespace also registered an ExtensionObject constructor with
+     * the address space's DataType manager; the factory holding those is dropped here, so that
+     * a later `ensureDatatypeExtracted` builds a fresh one for the repopulated namespace rather
+     * than colliding with the leftovers of the previous one.
+     */
+    public deleteNamespace(namespaceIndexOrUri: number | string): void {
+        const namespace = this.getNamespace(namespaceIndexOrUri);
+        /* c8 ignore next */
+        if (!namespace) {
+            throw new Error(`deleteNamespace: no namespace ${namespaceIndexOrUri.toString()} in this address space`);
+        }
+        const index = namespace.index;
+        if (index === 0) {
+            throw new Error("deleteNamespace: the standard namespace (index 0) cannot be deleted");
+        }
+
+        this.modelChangeTransaction(() => {
+            namespace._deleteAllNodes();
+        });
+
+        // a historized variable of the namespace is gone; the address space must stop listing it
+        if (this.historizingNodes.size) {
+            for (const node of [...this.historizingNodes]) {
+                if (node.nodeId.namespace === index) {
+                    this.historizingNodes.delete(node);
+                }
+            }
+        }
+
+        // the structures and enumerations this namespace registered go with their factory
+        this.$$extraDataTypeManager?.unregisterDataTypeFactory(index);
+    }
+
     /***
      * @return {Namespace[]} the namespace array
      */

package/impl/address_space_change_event_tools.ts

@@ -47,6 +47,7 @@ function _getTypeDef(node: BaseNode) {
 }
 export function _handle_add_reference_change_event(node1: BaseNode, node2id: NodeId): void {
     const addressSpace = node1.addressSpace as AddressSpacePrivate;
+    if (addressSpace.suspendModelChangeEvents) return;
     const node2 = addressSpace.findNode(node2id);
     if (!node2) return;
 
@@ -98,6 +99,7 @@ try {
 
 export function _handle_model_change_event(node: BaseNodeImpl): void {
     const addressSpace = node.addressSpace as AddressSpacePrivate;
+    if (addressSpace.suspendModelChangeEvents) return;
     //
     const parents = node.parent ? [node.parent] : [];
 
@@ -143,6 +145,11 @@ export function _handle_model_change_event(node: BaseNodeImpl): void {
 
 export function _handle_delete_node_model_change_event(node: BaseNode): void {
     const addressSpace = node.addressSpace as AddressSpacePrivate;
+    // The probe below - an inverse reference scan, then a findNode and a getNodeVersion per
+    // parent - runs on every node deleted, only to conclude that nothing has a NodeVersion and
+    // there is nothing to record. A loader or a compiler has no GeneralModelChangeEventType
+    // subscriber at all, and says so by setting this; see AddressSpace#suspendModelChangeEvents.
+    if (addressSpace.suspendModelChangeEvents) return;
 
     // get backward references
     const references = node.findReferencesEx("HierarchicalReferences", BrowseDirection.Inverse);

package/impl/address_space_private.ts

@@ -32,6 +32,7 @@ export interface AddressSpacePrivate extends IAddressSpace {
 
     isFrugal: boolean;
     suspendBackReference: boolean;
+    suspendModelChangeEvents: boolean;
 
     _condition_refresh_in_progress: boolean;
 

package/impl/alarms_and_conditions/condition_snapshot_impl.ts

@@ -95,7 +95,7 @@ export class ConditionSnapshotImpl extends EventEmitter implements ConditionSnap
         for (const fullBrowsePath of this._map.keys()) {
             const node = this._node_index.get(fullBrowsePath);
             if (!node) {
-                // c8 ignore next
+                /* c8 ignore next */
                 doDebug && debugLog("cannot node for find key", fullBrowsePath);
                 continue;
             }

package/impl/alarms_and_conditions/deviation_alarm_helper.ts

@@ -61,6 +61,9 @@ export function DeviationAlarmHelper_install_setpoint(this: DeviationStuff, opti
         });
         // install inputNode monitoring for change
         this.setpointNodeNode.on("value_changed", (newDataValue: DataValue) => {
+            // deliberately the deprecated name, for the same reason as _setStateBasedOnInputValue:
+            // an old subclass that overrode `_onSetpointDataValueChange` is still reached, and a
+            // new assignment of the published name is reached through the delegate on the impl.
             this._onSetpointDataValueChange(newDataValue);
         });
     } else {

package/impl/alarms_and_conditions/ua_acknowledgeable_condition_impl.ts

@@ -239,7 +239,7 @@ export class UAAcknowledgeableConditionImplBase<
         assert(!branch.getConfirmedState(), "already confirmed ?");
         const conditionEventId = branch.getEventId();
 
-        // c8 ignore next
+        /* c8 ignore next */
         doDebug && debugLog("autoConfirmBranch getAckedState ", branch.getAckedState());
         this._confirm_branch(conditionEventId, comment, branch, "Server/Confirm");
     }

package/impl/alarms_and_conditions/ua_alarm_condition_impl.ts

@@ -290,7 +290,7 @@ export class UAAlarmConditionImplBase extends UAAcknowledgeableConditionImplBase
 
             const _node = addressSpace._coerceNode(inputNode);
             if (_node === null) {
-                // c8 ignore next
+                /* c8 ignore next */
                 doDebug && debugLog(" cannot find nodeId ", inputNode);
             } else {
                 assert(_node, "Expecting a valid input node");

package/impl/alarms_and_conditions/ua_condition_impl.ts

@@ -570,7 +570,7 @@ export class UAConditionImplBase<T extends UAConditionEvents & ListenerSignature
         // for the time being , only current branch
         const currentBranch = this.currentBranch();
         if (currentBranch.getRetain()) {
-            // c8 ignore next
+            /* c8 ignore next */
             doDebug && debugLog(` resending condition event for ${this.browseName.toString()}`);
             this.raiseConditionEvent(currentBranch, false);
             return 1;

package/impl/alarms_and_conditions/ua_exclusive_deviation_alarm_impl.ts

@@ -70,10 +70,21 @@ export class UAExclusiveDeviationAlarmImplBase extends UAExclusiveLimitAlarmImpl
         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_deviation_alarm_impl.ts

@@ -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/bulk_load_clock.ts

@@ -0,0 +1,65 @@
+/**
+ * @module node-opcua-address-space
+ *
+ * One clock reading for one bulk load.
+ *
+ * Constructing a Variable stamps it with `getCurrentClock()`, and so does setting its initial
+ * value — twice per variable, thousands of times per nodeset, for a timestamp that means
+ * "when this was loaded". The readings differ by microseconds and nothing depends on the
+ * difference; the syscall behind them is ~1.4% of a load.
+ *
+ * The reading is taken once when a load begins and reused until it ends. Two things make that
+ * safe rather than merely cheaper:
+ *
+ *  - it is scoped to the **address space being loaded**, not to the process. A server writing
+ *    to a different address space, or to this one outside a load, still gets a real clock. A
+ *    module-global freeze would have leaked a stale timestamp into any concurrent write.
+ *  - it is **reference counted**, so loading a nodeset into an address space that is already
+ *    mid-load — grafting onto a partially built space — does not end the freeze early.
+ *
+ * What changes observably: every Variable a single load creates carries the same
+ * `sourceTimestamp` instead of timestamps a few microseconds apart. For nodes that came from
+ * one file, at one instant, that is arguably the more truthful answer; it is a change all the
+ * same, which is why it is confined to loading.
+ */
+import { getCurrentClock, type PreciseClock } from "node-opcua-date-time";
+
+interface Frozen {
+    clock: PreciseClock;
+    depth: number;
+}
+
+/**
+ * Keyed weakly, so an address space that is disposed and dropped takes its entry with it —
+ * a load that throws before `endBulkLoadClock` cannot pin one either.
+ */
+const frozen = new WeakMap<object, Frozen>();
+
+/** begin a load: take the reading the load will stamp everything with */
+export function beginBulkLoadClock(addressSpace: object): void {
+    const existing = frozen.get(addressSpace);
+    if (existing) {
+        existing.depth += 1;
+        return;
+    }
+    frozen.set(addressSpace, { clock: getCurrentClock(), depth: 1 });
+}
+
+/** end a load; the innermost end of a nested pair is not the one that thaws it */
+export function endBulkLoadClock(addressSpace: object): void {
+    const existing = frozen.get(addressSpace);
+    if (!existing) return;
+    existing.depth -= 1;
+    if (existing.depth <= 0) {
+        frozen.delete(addressSpace);
+    }
+}
+
+/**
+ * the clock to stamp a node with: the load's reading while one is in progress for this address
+ * space, a fresh reading otherwise.
+ */
+export function loadClock(addressSpace: object | null | undefined): PreciseClock {
+    const existing = addressSpace ? frozen.get(addressSpace) : undefined;
+    return existing ? existing.clock : getCurrentClock();
+}

package/impl/data_access/semantics_changed.ts

@@ -25,7 +25,9 @@
 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";
+import { NodeId, resolveNodeId } from "node-opcua-nodeid";
+import { SemanticChangeStructureDataType } from "node-opcua-types";
+import { DataType, VariantArrayType } from "node-opcua-variant";
 
 /**
  * the Properties whose value carries the semantics of the DataItem they belong to.
@@ -100,3 +102,39 @@ export function notifySemanticsChangedIfNeeded(property: UAVariable): void {
         (dataItem as UAVariable & { handle_semantic_changed: (dataValue?: unknown) => void }).handle_semantic_changed();
     }
 }
+
+/**
+ * OPC 10000-5 6.4.31: besides the SemanticsChanged bit on the DataItem's next notification, the
+ * Server reports a semantics change as a SemanticChangeEventType on the Server object, carrying
+ * the affected Node and its TypeDefinition. A client subscribed to the Server's events learns of
+ * the change without monitoring the DataItem itself.
+ *
+ * Raised from `handle_semantic_changed`, the single point every semantics change goes through, so
+ * the event and the bit can never disagree. Modelled on how the address space raises
+ * GeneralModelChangeEventType.
+ */
+export function raiseSemanticChangeEvent(dataItem: UAVariable): void {
+    const addressSpace = dataItem.addressSpace;
+    // during construction and teardown there is no Server object to raise the event on
+    const server = addressSpace?.rootFolder?.objects?.server;
+    if (!server) {
+        return;
+    }
+    const eventTypeNode = addressSpace.findEventType("SemanticChangeEventType");
+    if (!eventTypeNode) {
+        return;
+    }
+    const changes = [
+        new SemanticChangeStructureDataType({
+            affected: dataItem.nodeId,
+            affectedType: dataItem.typeDefinitionObj?.nodeId ?? NodeId.nullNodeId
+        })
+    ];
+    server.raiseEvent(eventTypeNode, {
+        changes: {
+            dataType: DataType.ExtensionObject,
+            arrayType: VariantArrayType.Array,
+            value: changes
+        }
+    });
+}

package/impl/data_access/ua_multistate_discrete_impl.ts

@@ -22,7 +22,7 @@ import { registerNodePromoter } from "../../api/loader/register_node_promoter.js
 import { UAVariableImpl, UAVariableImplT } from "../ua_variable_impl.js";
 import { add_dataItem_stuff } from "./add_dataItem_stuff.js";
 
-export { UAMultiStateDiscrete } from "node-opcua-nodeset-ua";
+export type { UAMultiStateDiscrete } from "node-opcua-nodeset-ua";
 
 // One declaration, in the api tree, rather than a lesser copy here: this file used to
 // declare its own UAMultiStateDiscreteEx without the UAVariableT half, so the two drifted

package/impl/extension_object_array_node.ts

@@ -53,7 +53,7 @@ function removeElementByIndex<T extends ExtensionObject>(uaArrayVariableNode: UA
     }
 
     const hasComponent = uaArrayVariableNode.addressSpace.findReferenceType("HasComponent");
-    // c8 ignore next
+    /* c8 ignore next */
     if (!hasComponent) {
         throw new Error("cannot find HasComponent reference type: please check your nodeset file");
     }
@@ -95,7 +95,7 @@ export function createExtObjArrayNode<T extends ExtensionObject>(
     const namespace = parentFolder.namespace;
 
     const complexVariableType = addressSpace.findVariableType(options.complexVariableType);
-    // c8 ignore next
+    /* c8 ignore next */
     if (!complexVariableType) {
         throw new Error("cannot find complex variable type");
     }
@@ -108,14 +108,14 @@ export function createExtObjArrayNode<T extends ExtensionObject>(
     assert(!variableType.nodeId.isEmpty());
 
     const structure = addressSpace.findDataType("Structure");
-    // c8 ignore next
+    /* c8 ignore next */
     if (!structure) {
         throw new Error("Structure Type not found: please check your nodeset file");
     }
 
     const dataType = addressSpace.findDataType(variableType.dataType);
 
-    // c8 ignore next
+    /* c8 ignore next */
     if (!dataType) {
         errorLog(variableType.toString());
         throw new Error("cannot find Data Type");
@@ -170,7 +170,7 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
     const addressSpace = uaArrayVariableNode.addressSpace;
 
     const variableType = addressSpace.findVariableType(variableTypeNodeId);
-    // c8 ignore next
+    /* c8 ignore next */
     if (!variableType || variableType.nodeId.isEmpty()) {
         throw new Error(`Cannot find VariableType ${variableTypeNodeId.toString()}`);
     }

package/impl/historical_access/address_space_historical_data_node.ts

@@ -447,12 +447,12 @@ function _historyReadRaw(
 
     const session = context.session;
 
-    // c8 ignore next
+    /* c8 ignore next */
     if (!session) {
         throw new Error("Internal Error: context.session not defined");
     }
 
-    // c8 ignore next
+    /* c8 ignore next */
     if (!session.continuationPointManager) {
         throw new Error("Internal Error: context.session.continuationPointManager not defined");
     }

package/impl/namespace_impl.ts

@@ -110,6 +110,7 @@ import { UANonExclusiveDeviationAlarmImplBase } from "./alarms_and_conditions/ua
 import { UANonExclusiveLimitAlarmImplBase } from "./alarms_and_conditions/ua_non_exclusive_limit_alarm_impl.js";
 import { type UAOffNormalAlarmEx, UAOffNormalAlarmImplBase } from "./alarms_and_conditions/ua_off_normal_alarm_impl.js";
 import { BaseNodeImpl } from "./base_node_impl.js";
+import { BaseNode_getPrivate } from "./base_node_private.js";
 import { add_dataItem_stuff } from "./data_access/add_dataItem_stuff.js";
 import { _addMultiStateDiscrete } from "./data_access/ua_multistate_discrete_impl.js";
 import { _addMultiStateValueDiscrete } from "./data_access/ua_multistate_value_discrete_impl.js";
@@ -140,7 +141,7 @@ function _makeHashKey(nodeId: NodeId): string | number {
         case NodeIdType.NUMERIC:
             return nodeId.value as number;
         default:
-            // c8 ignore next
+            /* c8 ignore next */
             if (nodeId.identifierType !== NodeIdType.BYTESTRING) {
                 throw new Error("invalid nodeIdType");
             }
@@ -265,7 +266,7 @@ export class NamespaceImpl implements NamespacePrivate {
     private defaultRolePermissions?: RolePermissionType[];
 
     constructor(options: NamespaceConstructorOptions) {
-        // c8 ignore next
+        /* c8 ignore next */
         if (!(typeof options.namespaceUri === "string")) {
             throw new Error(`NamespaceImpl constructor: namespaceUri must exists and be a string : got ${options.namespaceUri}`);
         }
@@ -830,6 +831,89 @@ export class NamespaceImpl implements NamespacePrivate {
         });
     }
 
+    /**
+     * Empty the namespace: every node it holds goes, and so does every reference that crossed
+     * between one of them and a node of another namespace. The namespace object itself survives,
+     * registered under the same index and uri, ready to be populated again - this is a recycle,
+     * not a {@link dispose}.
+     *
+     * Only the references that cross out are severed. A reference between two nodes of this
+     * namespace needs no work at all: both ends are about to be dropped and nothing outside will
+     * ever ask about them again. On a model grafted onto loaded base nodesets the crossing
+     * references are a small fraction of the total, which is what makes this cheaper than
+     * deleting the nodes one by one.
+     *
+     * @internal
+     *
+     * Callers want {@link IAddressSpace.deleteNamespace}: the rest of the operation - the single
+     * model-change transaction, the DataType factory of this namespace, the address space's set
+     * of historizing nodes - is address-space state that a namespace has no business reaching
+     * into.
+     */
+    public _deleteAllNodes(): void {
+        const addressSpace = this.addressSpace;
+        const index = this.index;
+
+        // a node deleted while someone watches for model changes still has to say so; the probe
+        // is skipped wholesale when nobody is listening (see AddressSpace#suspendModelChangeEvents)
+        for (const node of this._nodeid_index.values()) {
+            _handle_delete_node_model_change_event(node);
+        }
+
+        for (const node of this._nodeid_index.values()) {
+            const _private = BaseNode_getPrivate(node);
+            // snapshot first: removing the far end of a reference mutates this node's own indexes
+            const crossing: UAReference[] = [];
+            for (const ref of _private._referenceIdx.values()) {
+                if (ref.nodeId.namespace !== index) {
+                    crossing.push(ref);
+                }
+            }
+            for (const ref of _private._back_referenceIdx.values()) {
+                if (ref.nodeId.namespace !== index) {
+                    crossing.push(ref);
+                }
+            }
+            for (const ref of crossing) {
+                const other = addressSpace.findNode(ref.nodeId);
+                if (!other) {
+                    // the other end was never there, or has gone already: nothing holds this
+                    continue;
+                }
+                // removeReference copes with the reference being held by either end, and undoes
+                // the child accessor, the hierarchical index and the memoized scans on both
+                other.removeReference({
+                    isForward: !ref.isForward,
+                    nodeId: node.nodeId,
+                    referenceType: ref.referenceType
+                });
+            }
+        }
+
+        for (const node of this._nodeid_index.values()) {
+            (<BaseNodeImpl>node).dispose();
+        }
+
+        // the per-node unregister of _deleteNode would walk every map entry; emptying them
+        // outright says the same thing and is what makes the namespace reusable
+        this._nodeid_index = new Map();
+        this._aliases = new Map();
+        this._objectTypeMap = new Map();
+        this._variableTypeMap = new Map();
+        this._referenceTypeMap = new Map();
+        this._referenceTypeMapInv = new Map();
+        this._dataTypeMap = new Map();
+
+        // the counter restarts, so a second population hands out the same ids as the first; the
+        // symbolic name table is kept, for the same reason
+        this._nodeIdManager.reset();
+
+        // the header the nodeset carried, which the next population will set again
+        this._requiredModels = undefined;
+        this.version = "0.0.0";
+        this.publicationDate = new Date(Date.UTC(1900, 0, 1));
+    }
+
     /**
      * @internal
      */
@@ -1959,6 +2043,12 @@ export class NamespaceImpl implements NamespacePrivate {
             case NodeClass.VariableType:
                 this._unregisterVariableType(node as UAVariableType);
                 break;
+            case NodeClass.ReferenceType:
+                this._unregisterReferenceType(node as UAReferenceType);
+                break;
+            case NodeClass.DataType:
+                this._unregisterDataType(node as UADataType);
+                break;
             case NodeClass.Object:
             case NodeClass.Variable:
             case NodeClass.Method:
@@ -2101,6 +2191,33 @@ export class NamespaceImpl implements NamespacePrivate {
         this._variableTypeMap.delete(key);
     }
 
+    /**
+     * the mirror of `_registerReferenceType`: both maps it fills have to be emptied, the inverse
+     * one keyed on the inverse name rather than the browse name.
+     *
+     * Only an entry that still points at this very node goes: `_registerReferenceType` does not
+     * refuse a duplicate key the way the object/variable/dataType ones do, so a second reference
+     * type of the same browse name (or the same inverse name) would otherwise have its entry
+     * removed by the deletion of the first.
+     */
+    private _unregisterReferenceType(node: UAReferenceType): void {
+        const key = node.browseName.name || "";
+        if (this._referenceTypeMap.get(key) === node) {
+            this._referenceTypeMap.delete(key);
+        }
+        const inverseKey = node.inverseName?.text || "";
+        if (this._referenceTypeMapInv.get(inverseKey) === node) {
+            this._referenceTypeMapInv.delete(inverseKey);
+        }
+    }
+
+    private _unregisterDataType(node: UADataType): void {
+        const key = node.browseName.name || "";
+        if (this._dataTypeMap.get(key) === node) {
+            this._dataTypeMap.delete(key);
+        }
+    }
+
     /**
      * @private
      */

package/impl/namespace_private.ts

@@ -30,6 +30,9 @@ export interface NamespacePrivate extends Namespace {
 
     _deleteNode(node: BaseNode): void;
 
+    /** @see IAddressSpace.deleteNamespace, which is the way to reach this */
+    _deleteAllNodes(): void;
+
     internalCreateNode(options: CreateNodeOptions): BaseNode;
 
     registerSymbolicNames: boolean;