node-opcua-address-space 2.183.0 → 2.184.0

package/dist/impl/ua_variable_impl.js

@@ -1,72 +1,65 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UAVariableImplT = exports.UAVariableImpl = void 0;
-exports.adjust_accessLevel = adjust_accessLevel;
-exports.adjust_userAccessLevel = adjust_userAccessLevel;
 /**
  * @module node-opcua-address-space
  */
-const node_util_1 = require("node:util");
-const chalk_1 = __importDefault(require("chalk"));
-const node_opcua_address_space_base_1 = require("node-opcua-address-space-base");
-const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_data_model_1 = require("node-opcua-data-model");
-const node_opcua_data_value_1 = require("node-opcua-data-value");
-const node_opcua_date_time_1 = require("node-opcua-date-time");
-const node_opcua_debug_1 = require("node-opcua-debug");
-const node_opcua_extension_object_1 = require("node-opcua-extension-object");
-const node_opcua_nodeid_1 = require("node-opcua-nodeid");
-const node_opcua_numeric_range_1 = require("node-opcua-numeric-range");
-const node_opcua_service_write_1 = require("node-opcua-service-write");
-const node_opcua_status_code_1 = require("node-opcua-status-code");
-const node_opcua_types_1 = require("node-opcua-types");
-const node_opcua_variant_1 = require("node-opcua-variant");
-const multiform_func_js_1 = require("../api/helpers/multiform_func.js");
-const session_context_js_1 = require("../api/session_context.js");
-const apply_condition_refresh_js_1 = require("./apply_condition_refresh.js");
-const base_node_impl_js_1 = require("./base_node_impl.js");
-const base_node_private_js_1 = require("./base_node_private.js");
-const adjust_datavalue_status_code_js_1 = require("./data_access/adjust_datavalue_status_code.js");
-const semantics_changed_js_1 = require("./data_access/semantics_changed.js");
-const get_basic_datatype_js_1 = require("./get_basic_datatype.js");
-const ua_data_type_impl_js_1 = require("./ua_data_type_impl.js");
-const ua_variable_impl_ext_obj_js_1 = require("./ua_variable_impl_ext_obj.js");
-const validate_data_type_correctness_js_1 = require("./validate_data_type_correctness.js");
-const debugLog = (0, node_opcua_debug_1.make_debugLog)("ua_variable_impl");
-const warningLog = (0, node_opcua_debug_1.make_warningLog)("ua_variable_impl");
-const doDebug = (0, node_opcua_debug_1.checkDebugFlag)("ua_variable_impl");
-const errorLog = (0, node_opcua_debug_1.make_errorLog)("ua_variable_impl");
+import { types } from "node:util";
+import chalk from "chalk";
+import { defaultCloneFilter, makeDefaultCloneExtraInfo } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { AccessLevelFlag, AttributeIds, convertAccessLevelFlagToByte, isDataEncoding, isValidDataEncoding, makeAccessLevelFlag, NodeClass } from "node-opcua-data-model";
+import { DataValue, extractRange, makeNowDataValue, sameDataValue } from "node-opcua-data-value";
+import { coerceClock, getCurrentClock } from "node-opcua-date-time";
+import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
+import { ExtensionObject, OpaqueStructure } from "node-opcua-extension-object";
+import { NodeId } from "node-opcua-nodeid";
+import { NumericRange } from "node-opcua-numeric-range";
+import { WriteValue } from "node-opcua-service-write";
+import { StatusCode, StatusCodes } from "node-opcua-status-code";
+import { HistoryReadResult, PermissionType } from "node-opcua-types";
+import { adjustVariant, DataType, sameVariant, Variant, VariantArrayType, verifyRankAndDimensions } from "node-opcua-variant";
+import { convertToCallbackFunction1 } from "../api/helpers/multiform_func.js";
+import { SessionContext } from "../api/session_context.js";
+import { apply_condition_refresh } from "./apply_condition_refresh.js";
+import { BaseNodeImpl } 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, raiseSemanticChangeEvent } from "./data_access/semantics_changed.js";
+import { _getBasicDataType } from "./get_basic_datatype.js";
+import { UADataTypeImpl } from "./ua_data_type_impl.js";
+import { _bindExtensionObject, _bindExtensionObjectArrayOrMatrix, _installExtensionObjectBindingOnProperties, extractPartialData, incrementElement, propagateTouchValueDownward, propagateTouchValueDownwardArray, propagateTouchValueUpward, setExtensionObjectPartialValue } from "./ua_variable_impl_ext_obj.js";
+import { validateDataTypeCorrectness } from "./validate_data_type_correctness.js";
+const debugLog = make_debugLog("ua_variable_impl");
+const warningLog = make_warningLog("ua_variable_impl");
+const doDebug = checkDebugFlag("ua_variable_impl");
+const errorLog = make_errorLog("ua_variable_impl");
 // a colourless chalk; see ua_object_impl.ts for why it is not a Proxy over `chalk`
-const plainChalk = new chalk_1.default.Instance({ level: 0 });
-function adjust_accessLevel(accessLevel) {
-    const flag = (0, node_opcua_data_model_1.makeAccessLevelFlag)(accessLevel ?? "CurrentRead | CurrentWrite");
-    (0, node_opcua_assert_1.assert)(Number.isFinite(flag));
+const plainChalk = new chalk.Instance({ level: 0 });
+export function adjust_accessLevel(accessLevel) {
+    const flag = makeAccessLevelFlag(accessLevel ?? "CurrentRead | CurrentWrite");
+    assert(Number.isFinite(flag));
     return flag;
 }
-function adjust_userAccessLevel(userAccessLevel, accessLevel) {
+export function adjust_userAccessLevel(userAccessLevel, accessLevel) {
     if (userAccessLevel === undefined) {
         return undefined;
     }
     userAccessLevel = adjust_accessLevel(userAccessLevel);
     accessLevel = adjust_accessLevel(accessLevel);
-    return (0, node_opcua_data_model_1.makeAccessLevelFlag)(accessLevel & userAccessLevel);
+    return makeAccessLevelFlag(accessLevel & userAccessLevel);
 }
 function adjust_samplingInterval(minimumSamplingInterval) {
-    (0, node_opcua_assert_1.assert)(Number.isFinite(minimumSamplingInterval));
+    assert(Number.isFinite(minimumSamplingInterval));
     if (minimumSamplingInterval < 0) {
         return -1; // only -1 is a valid negative value for samplingInterval and means "unspecified"
     }
     return minimumSamplingInterval;
 }
 function is_Variant(v) {
-    return v instanceof node_opcua_variant_1.Variant;
+    return v instanceof Variant;
 }
 function is_StatusCode(v) {
     return !!(v?.constructor &&
-        (v instanceof node_opcua_status_code_1.StatusCode ||
+        (v instanceof StatusCode ||
             v.constructor.name === "ConstantStatusCode" ||
             v.constructor.name === "StatusCode" ||
             v.constructor.name === "ModifiableStatusCode"));
@@ -106,7 +99,7 @@ function default_func(dataValue1, callback1) {
  *  indicates if the history of the Variable is available via the OPC UA server.
  *
  */
-class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
+export class UAVariableImpl extends BaseNodeImpl {
     // -------------- UAvaraibleImplExArray
     $$variableType;
     $$dataType = undefined;
@@ -114,7 +107,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     $$extensionObjectArray;
     $$indexPropertyName;
     // --------------
-    nodeClass = node_opcua_data_model_1.NodeClass.Variable;
+    nodeClass = NodeClass.Variable;
     dataType;
     _basicDataType;
     // narrowing this to ExtensionObject breaks declaration-merging in ua_two_state_variable.ts and elsewhere
@@ -143,8 +136,8 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     refreshFunc;
     __waiting_callbacks;
     get typeDefinitionObj() {
-        // c8 ignore next
-        if (super.typeDefinitionObj && super.typeDefinitionObj.nodeClass !== node_opcua_data_model_1.NodeClass.VariableType) {
+        /* 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
             warningLog(super.typeDefinitionObj.toString());
@@ -160,7 +153,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     }
     constructor(options) {
         super(options);
-        (0, node_opcua_variant_1.verifyRankAndDimensions)(options);
+        verifyRankAndDimensions(options);
         this.valueRank = options.valueRank ?? -1;
         this.arrayDimensions = options.arrayDimensions ?? null;
         this.dataType = this.resolveNodeId(options.dataType); // DataType (NodeId)
@@ -171,11 +164,13 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         // 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 = (0, node_opcua_date_time_1.getCurrentClock)();
-        this.$dataValue = new node_opcua_data_value_1.DataValue({
-            statusCode: node_opcua_status_code_1.StatusCodes.UncertainInitialValue,
-            value: new node_opcua_variant_1.Variant(null),
+        // 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),
             sourceTimestamp: now.timestamp,
             sourcePicoseconds: now.picoseconds,
             serverTimestamp: now.timestamp,
@@ -196,7 +191,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     checkPermissionPrivate(context, permission) {
         if (!context)
             return true;
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
+        assert(context instanceof SessionContext);
         if (context.checkPermission) {
             if (!(context.checkPermission instanceof Function)) {
                 errorLog("context checkPermission is not a function");
@@ -215,43 +210,43 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         return this.checkAccessLevelPrivate(context, accessLevel);
     }
     isReadable(_context) {
-        return (this.accessLevel & node_opcua_data_model_1.AccessLevelFlag.CurrentRead) === node_opcua_data_model_1.AccessLevelFlag.CurrentRead;
+        return (this.accessLevel & AccessLevelFlag.CurrentRead) === AccessLevelFlag.CurrentRead;
     }
     isUserReadable(context) {
         if (!this.isReadable(context)) {
             return false;
         }
-        if (!this.checkPermissionPrivate(context, node_opcua_types_1.PermissionType.Read)) {
+        if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
             return false;
         }
-        return this.checkAccessLevelPrivate(context, node_opcua_data_model_1.AccessLevelFlag.CurrentRead);
+        return this.checkAccessLevelPrivate(context, AccessLevelFlag.CurrentRead);
     }
     isWritable(_context) {
-        return (this.accessLevel & node_opcua_data_model_1.AccessLevelFlag.CurrentWrite) === node_opcua_data_model_1.AccessLevelFlag.CurrentWrite;
+        return (this.accessLevel & AccessLevelFlag.CurrentWrite) === AccessLevelFlag.CurrentWrite;
     }
     isUserWritable(context) {
         if (!this.isWritable(context)) {
             return false;
         }
-        return this.checkPermissionAndAccessLevelPrivate(context, node_opcua_types_1.PermissionType.Write, node_opcua_data_model_1.AccessLevelFlag.CurrentWrite);
+        return this.checkPermissionAndAccessLevelPrivate(context, PermissionType.Write, AccessLevelFlag.CurrentWrite);
     }
     canUserReadHistory(context) {
-        return this.checkPermissionAndAccessLevelPrivate(context, node_opcua_types_1.PermissionType.ReadHistory, node_opcua_data_model_1.AccessLevelFlag.HistoryRead);
+        return this.checkPermissionAndAccessLevelPrivate(context, PermissionType.ReadHistory, AccessLevelFlag.HistoryRead);
     }
     canUserWriteHistorizingAttribute(context) {
-        if (context && !context.checkPermission(this, node_opcua_types_1.PermissionType.WriteHistorizing)) {
+        if (context && !context.checkPermission(this, PermissionType.WriteHistorizing)) {
             return false;
         }
         return true;
     }
     canUserInsertHistory(context) {
-        return this.checkPermissionAndAccessLevelPrivate(context, node_opcua_types_1.PermissionType.InsertHistory, node_opcua_data_model_1.AccessLevelFlag.HistoryWrite);
+        return this.checkPermissionAndAccessLevelPrivate(context, PermissionType.InsertHistory, AccessLevelFlag.HistoryWrite);
     }
     canUserModifyHistory(context) {
-        return this.checkPermissionAndAccessLevelPrivate(context, node_opcua_types_1.PermissionType.ModifyHistory, node_opcua_data_model_1.AccessLevelFlag.HistoryWrite);
+        return this.checkPermissionAndAccessLevelPrivate(context, PermissionType.ModifyHistory, AccessLevelFlag.HistoryWrite);
     }
     canUserDeleteHistory(context) {
-        return this.checkPermissionAndAccessLevelPrivate(context, node_opcua_types_1.PermissionType.DeleteHistory, node_opcua_data_model_1.AccessLevelFlag.HistoryWrite);
+        return this.checkPermissionAndAccessLevelPrivate(context, PermissionType.DeleteHistory, AccessLevelFlag.HistoryWrite);
     }
     /**
      *
@@ -282,7 +277,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
      */
     readValue(context, indexRange, dataEncoding) {
         if (!context) {
-            context = session_context_js_1.SessionContext.defaultContext;
+            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
@@ -291,20 +286,20 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         // 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 (0, node_opcua_data_value_1.makeNowDataValue)({ statusCode: node_opcua_status_code_1.StatusCodes.BadSecurityModeInsufficient });
+            return makeNowDataValue({ statusCode: StatusCodes.BadSecurityModeInsufficient });
         }
         if (!this.isReadable(context)) {
-            return (0, node_opcua_data_value_1.makeNowDataValue)({ statusCode: node_opcua_status_code_1.StatusCodes.BadNotReadable });
+            return makeNowDataValue({ statusCode: StatusCodes.BadNotReadable });
         }
-        if (!this.checkPermissionPrivate(context, node_opcua_types_1.PermissionType.Read)) {
-            return (0, node_opcua_data_value_1.makeNowDataValue)({ statusCode: node_opcua_status_code_1.StatusCodes.BadUserAccessDenied });
+        if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
+            return makeNowDataValue({ statusCode: StatusCodes.BadUserAccessDenied });
         }
         if (!this.isUserReadable(context)) {
-            return (0, node_opcua_data_value_1.makeNowDataValue)({ statusCode: node_opcua_status_code_1.StatusCodes.BadNotReadable });
+            return makeNowDataValue({ statusCode: StatusCodes.BadNotReadable });
         }
-        if (!(0, node_opcua_data_model_1.isValidDataEncoding)(dataEncoding)) {
+        if (!isValidDataEncoding(dataEncoding)) {
             // Table 51: no encoding can be applied to a non-Structure value
-            return (0, node_opcua_data_value_1.makeNowDataValue)({ statusCode: node_opcua_status_code_1.StatusCodes.BadDataEncodingInvalid });
+            return makeNowDataValue({ statusCode: StatusCodes.BadDataEncodingInvalid });
         }
         if (this._timestamped_get_func) {
             if (this._timestamped_get_func.length === 0) {
@@ -312,7 +307,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                 if (!Object.hasOwn(dataValueOrPromise.constructor.prototype, "then")) {
                     if (dataValueOrPromise !== this.$dataValue) {
                         // we may have a problem here if we use a getter that returns a dataValue that is a ExtensionObject
-                        if (dataValueOrPromise.value?.dataType === node_opcua_variant_1.DataType.ExtensionObject) {
+                        if (dataValueOrPromise.value?.dataType === DataType.ExtensionObject) {
                             if (this.$extensionObject || this.$$extensionObjectArray) {
                                 // we have an extension object already bound to this node
                                 // the client is asking us to replace the object entirely by a new one
@@ -336,17 +331,17 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         let dataValue = this.$dataValue;
         if (dataValue.statusCode.isGoodish()) {
             // note : extractRange will clone the dataValue
-            dataValue = (0, node_opcua_data_value_1.extractRange)(dataValue, indexRange);
+            dataValue = extractRange(dataValue, indexRange);
         }
         /* c8 ignore next */
-        if (dataValue.statusCode.equals(node_opcua_status_code_1.StatusCodes.BadWaitingForInitialData) ||
-            dataValue.statusCode.equals(node_opcua_status_code_1.StatusCodes.UncertainInitialValue)) {
-            // c8 ignore next
+        if (dataValue.statusCode.equals(StatusCodes.BadWaitingForInitialData) ||
+            dataValue.statusCode.equals(StatusCodes.UncertainInitialValue)) {
+            /* c8 ignore next */
             doDebug &&
-                debugLog(chalk_1.default.red(" Warning:  UAVariable#readValue ") +
-                    chalk_1.default.cyan(this.browseName.toString()) +
+                debugLog(chalk.red(" Warning:  UAVariable#readValue ") +
+                    chalk.cyan(this.browseName.toString()) +
                     " (" +
-                    chalk_1.default.yellow(this.nodeId.toString()) +
+                    chalk.yellow(this.nodeId.toString()) +
                     ") exists but dataValue has not been defined");
         }
         return dataValue;
@@ -374,7 +369,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     }
     _getEnumerationInfo() {
         // DataType must be one of Enumeration
-        (0, node_opcua_assert_1.assert)(this.isEnumeration(), "Variable is not an enumeration");
+        assert(this.isEnumeration(), "Variable is not an enumeration");
         const dataTypeNode = this.addressSpace.findDataType(this.dataType);
         return dataTypeNode._getEnumerationInfo();
     }
@@ -395,7 +390,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             const dataValue = this.readValue();
             dataValue.serverTimestamp = oldestDate.timestamp;
             dataValue.serverPicoseconds = oldestDate.picoseconds;
-            const serverClock = (0, node_opcua_date_time_1.coerceClock)(dataValue.serverTimestamp, dataValue.serverPicoseconds);
+            const serverClock = coerceClock(dataValue.serverTimestamp, dataValue.serverPicoseconds);
             if (lessOrEqual(oldestDate, serverClock)) {
                 cb(null, dataValue);
                 return;
@@ -407,7 +402,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             }
         }
         const c1 = this.$dataValue.serverTimestamp
-            ? (0, node_opcua_date_time_1.coerceClock)(this.$dataValue.serverTimestamp, this.$dataValue.serverPicoseconds)
+            ? coerceClock(this.$dataValue.serverTimestamp, this.$dataValue.serverPicoseconds)
             : null;
         if (c1 && lessOrEqual(oldestDate, c1)) {
             const dataValue = this.readValue().clone();
@@ -421,7 +416,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                 // c8 ignore next
                 if (err || !dataValue) {
                     errorLog("-------------- refresh call failed", this.browseName.toString(), this.nodeId.toString(), err?.message);
-                    dataValue = { statusCode: node_opcua_status_code_1.StatusCodes.BadNoDataAvailable };
+                    dataValue = { statusCode: StatusCodes.BadNoDataAvailable };
                 }
                 if (dataValue && dataValue !== this.$dataValue) {
                     this._internal_set_dataValue(coerceDataValue(dataValue), null);
@@ -432,7 +427,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         catch (err) {
             errorLog("-------------- refresh call failed 2", this.browseName.toString(), this.nodeId.toString());
             errorLog(err);
-            const dataValue = new node_opcua_data_value_1.DataValue({ statusCode: node_opcua_status_code_1.StatusCodes.BadInternalError });
+            const dataValue = new DataValue({ statusCode: StatusCodes.BadInternalError });
             this._internal_set_dataValue(dataValue, null);
             cb(err, this.$dataValue);
         }
@@ -460,7 +455,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                 throw new Error(`UAVariable#writeEnumValue : value out of range ${value} in [${possibleValues}]`);
             }
             this.setValueFromSource({
-                dataType: node_opcua_variant_1.DataType.Int32,
+                dataType: DataType.Int32,
                 value
             });
         }
@@ -469,47 +464,47 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         }
     }
     readAttribute(context, attributeId, indexRange, dataEncoding) {
-        context = context || session_context_js_1.SessionContext.defaultContext;
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
+        context = context || SessionContext.defaultContext;
+        assert(context instanceof SessionContext);
         const options = {};
-        if (attributeId !== node_opcua_data_model_1.AttributeIds.Value) {
+        if (attributeId !== AttributeIds.Value) {
             if (indexRange?.isDefined()) {
-                options.statusCode = node_opcua_status_code_1.StatusCodes.BadIndexRangeNoData;
-                return new node_opcua_data_value_1.DataValue(options);
+                options.statusCode = StatusCodes.BadIndexRangeNoData;
+                return new DataValue(options);
             }
-            if ((0, node_opcua_data_model_1.isDataEncoding)(dataEncoding)) {
-                options.statusCode = node_opcua_status_code_1.StatusCodes.BadDataEncodingInvalid;
-                return new node_opcua_data_value_1.DataValue(options);
+            if (isDataEncoding(dataEncoding)) {
+                options.statusCode = StatusCodes.BadDataEncodingInvalid;
+                return new DataValue(options);
             }
         }
         switch (attributeId) {
-            case node_opcua_data_model_1.AttributeIds.Value:
+            case AttributeIds.Value:
                 return this.readValue(context, indexRange, dataEncoding);
-            case node_opcua_data_model_1.AttributeIds.DataType:
+            case AttributeIds.DataType:
                 return this._readDataType();
-            case node_opcua_data_model_1.AttributeIds.ValueRank:
+            case AttributeIds.ValueRank:
                 return this._readValueRank();
-            case node_opcua_data_model_1.AttributeIds.ArrayDimensions:
+            case AttributeIds.ArrayDimensions:
                 return this._readArrayDimensions();
-            case node_opcua_data_model_1.AttributeIds.AccessLevel:
+            case AttributeIds.AccessLevel:
                 return this._readAccessLevel(context);
-            case node_opcua_data_model_1.AttributeIds.UserAccessLevel:
+            case AttributeIds.UserAccessLevel:
                 return this._readUserAccessLevel(context);
-            case node_opcua_data_model_1.AttributeIds.MinimumSamplingInterval:
+            case AttributeIds.MinimumSamplingInterval:
                 return this._readMinimumSamplingInterval();
-            case node_opcua_data_model_1.AttributeIds.Historizing:
+            case AttributeIds.Historizing:
                 return this._readHistorizing();
-            case node_opcua_data_model_1.AttributeIds.AccessLevelEx:
+            case AttributeIds.AccessLevelEx:
                 return this._readAccessLevelEx(context);
             default:
-                return base_node_impl_js_1.BaseNodeImpl.prototype.readAttribute.call(this, context, attributeId);
+                return BaseNodeImpl.prototype.readAttribute.call(this, context, attributeId);
         }
     }
     getBasicDataType() {
-        return (0, get_basic_datatype_js_1._getBasicDataType)(this);
+        return _getBasicDataType(this);
     }
     adjustVariant(variant) {
-        return (0, node_opcua_variant_1.adjustVariant)(variant, this.valueRank, this.getBasicDataType());
+        return adjustVariant(variant, this.valueRank, this.getBasicDataType());
     }
     verifyVariantCompatibility(variant) {
         try {
@@ -521,17 +516,17 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                         " this.dataType= " +
                         this.dataType.toString());
                 }
-                if (variant.dataType === node_opcua_variant_1.DataType.Boolean &&
-                    (this.dataType.namespace !== 0 || this.dataType.value !== node_opcua_variant_1.DataType.Boolean)) {
+                if (variant.dataType === DataType.Boolean &&
+                    (this.dataType.namespace !== 0 || this.dataType.value !== DataType.Boolean)) {
                     throw new Error("Variant must provide a valid Boolean : variant = " +
                         variant.toString() +
                         " this.dataType= " +
                         this.dataType.toString());
                 }
                 if (this.dataType.namespace === 0 &&
-                    this.dataType.value === node_opcua_variant_1.DataType.LocalizedText &&
-                    variant.dataType !== node_opcua_variant_1.DataType.LocalizedText &&
-                    variant.dataType !== node_opcua_variant_1.DataType.Null) {
+                    this.dataType.value === DataType.LocalizedText &&
+                    variant.dataType !== DataType.LocalizedText &&
+                    variant.dataType !== DataType.Null) {
                     throw new Error("Variant must provide a valid LocalizedText : variant = " +
                         variant.toString() +
                         " this.dataType= " +
@@ -539,15 +534,15 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                 }
             }
             const basicType = this.getBasicDataType();
-            if (basicType === node_opcua_variant_1.DataType.String && variant.dataType === node_opcua_variant_1.DataType.ByteString) {
+            if (basicType === DataType.String && variant.dataType === DataType.ByteString) {
                 return; // this is allowed
             }
-            if (basicType === node_opcua_variant_1.DataType.ByteString && variant.dataType === node_opcua_variant_1.DataType.String) {
+            if (basicType === DataType.ByteString && variant.dataType === DataType.String) {
                 return; // this is allowed
             }
-            if (basicType !== node_opcua_variant_1.DataType.Null &&
-                basicType !== node_opcua_variant_1.DataType.Variant &&
-                variant.dataType !== node_opcua_variant_1.DataType.Null &&
+            if (basicType !== DataType.Null &&
+                basicType !== DataType.Variant &&
+                variant.dataType !== DataType.Null &&
                 variant.dataType !== basicType) {
                 const message = "UAVariable.setValueFromSource " +
                     this.browseName.toString() +
@@ -558,10 +553,10 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                     ":\n" +
                     "the provided variant must have the expected dataType!\n" +
                     "   - the expected dataType is " +
-                    chalk_1.default.cyan(node_opcua_variant_1.DataType[basicType]) +
+                    chalk.cyan(DataType[basicType]) +
                     "\n" +
                     "   - the actual dataType   is " +
-                    chalk_1.default.magenta(node_opcua_variant_1.DataType[variant.dataType]) +
+                    chalk.magenta(DataType[variant.dataType]) +
                     "\n" +
                     "   - " +
                     variant.toString();
@@ -588,18 +583,18 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     */
     setValueFromSource(variant, statusCode, sourceTimestamp) {
         try {
-            statusCode = statusCode || node_opcua_status_code_1.StatusCodes.Good;
-            const variant1 = node_opcua_variant_1.Variant.coerce(variant);
+            statusCode = statusCode || StatusCodes.Good;
+            const variant1 = Variant.coerce(variant);
             this.verifyVariantCompatibility(variant1);
-            const now = (0, node_opcua_date_time_1.coerceClock)(sourceTimestamp, 0);
-            const dataValue = new node_opcua_data_value_1.DataValue(null);
+            const now = coerceClock(sourceTimestamp, 0);
+            const dataValue = new DataValue(null);
             dataValue.serverPicoseconds = now.picoseconds;
             dataValue.serverTimestamp = now.timestamp;
             dataValue.sourcePicoseconds = now.picoseconds;
             dataValue.sourceTimestamp = now.timestamp;
             dataValue.statusCode = statusCode;
             dataValue.value = variant1;
-            if (dataValue.value.dataType === node_opcua_variant_1.DataType.ExtensionObject) {
+            if (dataValue.value.dataType === DataType.ExtensionObject) {
                 // early, detailed diagnostics on a malformed extension object (the actual throw
                 // happens below in _internal_set_dataValue).
                 const valueIsCorrect = this.checkExtensionObjectIsCorrect(dataValue.value.value);
@@ -636,7 +631,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
      *
      * @internal
      */
-    _setInitialDataValue(variant, statusCode = node_opcua_status_code_1.StatusCodes.Good) {
+    _setInitialDataValue(variant, statusCode = StatusCodes.Good) {
         // the loader creates every variable with an empty value object, which the constructor
         // binds, so a bound setter is the norm here and not a reason to take the long path:
         // setValueFromSource never consults it either. A bound extension object is.
@@ -645,13 +640,14 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             return;
         }
         try {
-            const variant1 = node_opcua_variant_1.Variant.coerce(variant);
+            const variant1 = Variant.coerce(variant);
             this.verifyVariantCompatibility(variant1);
-            if (variant1.dataType === node_opcua_variant_1.DataType.ExtensionObject && !this.checkExtensionObjectIsCorrect(variant1.value)) {
+            if (variant1.dataType === DataType.ExtensionObject && !this.checkExtensionObjectIsCorrect(variant1.value)) {
                 throw new Error("invalid extension object");
             }
-            const now = (0, node_opcua_date_time_1.getCurrentClock)();
-            this.$dataValue = new node_opcua_data_value_1.DataValue({
+            // 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,
                 sourceTimestamp: now.timestamp,
@@ -665,12 +661,12 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         }
     }
     adjustDataValueStatusCode(dataValue) {
-        const statusCode = (0, adjust_datavalue_status_code_js_1.adjustDataValueStatusCode)(this, dataValue, this.acceptValueOutOfRange || false);
+        const statusCode = adjustDataValueStatusCode(this, dataValue, this.acceptValueOutOfRange || false);
         return statusCode;
     }
     writeValue(context, dataValue, ...args) {
-        context = context || session_context_js_1.SessionContext.defaultContext;
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
+        context = context || SessionContext.defaultContext;
+        assert(context instanceof SessionContext);
         if (!dataValue.sourceTimestamp) {
             // source timestamp was not specified by the caller
             // we will set the timestamp ourself with the current clock
@@ -679,7 +675,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                 dataValue.sourcePicoseconds = context.currentTime.picoseconds;
             }
             else {
-                const { timestamp, picoseconds } = (0, node_opcua_date_time_1.getCurrentClock)();
+                const { timestamp, picoseconds } = getCurrentClock();
                 dataValue.sourceTimestamp = timestamp;
                 dataValue.sourcePicoseconds = picoseconds;
             }
@@ -692,7 +688,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         let indexRange = null;
         let callback;
         if (args.length === 1) {
-            indexRange = new node_opcua_numeric_range_1.NumericRange();
+            indexRange = new NumericRange();
             callback = args[0];
         }
         else if (args.length === 2) {
@@ -702,30 +698,30 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         else {
             throw new Error("Invalid Number of args");
         }
-        (0, node_opcua_assert_1.assert)(typeof callback === "function");
-        (0, node_opcua_assert_1.assert)(dataValue instanceof node_opcua_data_value_1.DataValue);
+        assert(typeof callback === "function");
+        assert(dataValue instanceof DataValue);
         // index range could be string
-        indexRange = node_opcua_numeric_range_1.NumericRange.coerce(indexRange);
+        indexRange = NumericRange.coerce(indexRange);
         // test write permission
         if (!this.isWritable(context)) {
-            callback?.(null, node_opcua_status_code_1.StatusCodes.BadNotWritable);
+            callback?.(null, StatusCodes.BadNotWritable);
             return;
         }
-        if (!this.checkPermissionPrivate(context, node_opcua_types_1.PermissionType.Write)) {
-            callback?.(null, node_opcua_status_code_1.StatusCodes.BadUserAccessDenied);
+        if (!this.checkPermissionPrivate(context, PermissionType.Write)) {
+            callback?.(null, StatusCodes.BadUserAccessDenied);
             return;
         }
         // isWritable() and the role permission above already passed, so a false result
         // here can only come from the UserAccessLevel attribute withholding CurrentWrite
         // for this user (Part 3 5.6.3): that is an access decision, not an unsupported call.
         if (!this.isUserWritable(context)) {
-            callback?.(null, node_opcua_status_code_1.StatusCodes.BadUserAccessDenied);
+            callback?.(null, StatusCodes.BadUserAccessDenied);
             return;
         }
         // adjust special case
         const variant = adjustVariant2.call(this, dataValue.value);
         const statusCode = this.checkVariantCompatibility(variant);
-        if (statusCode.isNot(node_opcua_status_code_1.StatusCodes.Good)) {
+        if (statusCode.isNot(StatusCodes.Good)) {
             callback?.(null, statusCode);
             return;
         }
@@ -739,29 +735,29 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         if (!write_func) {
             warningLog(` warning ${this.nodeId.toString()} ${this.browseName.toString()} has no setter. \n`);
             warningLog("Please make sure to bind the variable or to pass a valid value: new Variant({}) during construction time");
-            callback?.(null, node_opcua_status_code_1.StatusCodes.BadNotWritable);
+            callback?.(null, StatusCodes.BadNotWritable);
             return;
         }
-        (0, node_opcua_assert_1.assert)(write_func);
+        assert(write_func);
         write_func.call(this, dataValue, (err, statusCode1) => {
             if (!err) {
                 dataValue && this.verifyVariantCompatibility(dataValue.value);
                 if (indexRange && !indexRange.isEmpty()) {
                     if (!indexRange.isValid()) {
-                        callback?.(null, node_opcua_status_code_1.StatusCodes.BadIndexRangeInvalid);
+                        callback?.(null, StatusCodes.BadIndexRangeInvalid);
                         return;
                     }
                     const newArrayOrMatrix = dataValue.value.value;
-                    if (dataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Array) {
-                        if (this.$dataValue.value.arrayType !== node_opcua_variant_1.VariantArrayType.Array) {
-                            callback(null, node_opcua_status_code_1.StatusCodes.BadTypeMismatch);
+                    if (dataValue.value.arrayType === VariantArrayType.Array) {
+                        if (this.$dataValue.value.arrayType !== VariantArrayType.Array) {
+                            callback(null, StatusCodes.BadTypeMismatch);
                             return;
                         }
                         // check that destination data is also an array
-                        (0, node_opcua_assert_1.assert)(check_valid_array(this.$dataValue.value.dataType, this.$dataValue.value.value));
+                        assert(check_valid_array(this.$dataValue.value.dataType, this.$dataValue.value.value));
                         const destArr = this.$dataValue.value.value;
                         const result = indexRange.set_values(destArr, newArrayOrMatrix);
-                        if (result.statusCode.isNot(node_opcua_status_code_1.StatusCodes.Good)) {
+                        if (result.statusCode.isNot(StatusCodes.Good)) {
                             callback?.(null, result.statusCode);
                             return;
                         }
@@ -769,11 +765,11 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                         // scrap original array so we detect range
                         this.$dataValue.value.value = null;
                     }
-                    else if (dataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Matrix) {
+                    else if (dataValue.value.arrayType === VariantArrayType.Matrix) {
                         const dimensions = this.$dataValue.value.dimensions;
-                        if (this.$dataValue.value.arrayType !== node_opcua_variant_1.VariantArrayType.Matrix || !dimensions) {
+                        if (this.$dataValue.value.arrayType !== VariantArrayType.Matrix || !dimensions) {
                             // not a matrix !
-                            callback?.(null, node_opcua_status_code_1.StatusCodes.BadTypeMismatch);
+                            callback?.(null, StatusCodes.BadTypeMismatch);
                             return;
                         }
                         const matrix = this.$dataValue.value.value;
@@ -781,7 +777,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                             matrix,
                             dimensions
                         }, newArrayOrMatrix);
-                        if (result.statusCode.isNot(node_opcua_status_code_1.StatusCodes.Good)) {
+                        if (result.statusCode.isNot(StatusCodes.Good)) {
                             callback?.(null, result.statusCode);
                             return;
                         }
@@ -791,7 +787,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                         this.$dataValue.value.value = null;
                     }
                     else {
-                        callback?.(null, node_opcua_status_code_1.StatusCodes.BadTypeMismatch);
+                        callback?.(null, StatusCodes.BadTypeMismatch);
                         return;
                     }
                 }
@@ -799,10 +795,10 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                     this._internal_set_dataValue(dataValue, indexRange);
                 }
                 catch (err) {
-                    if (node_util_1.types.isNativeError(err)) {
+                    if (types.isNativeError(err)) {
                         warningLog(err.message);
                     }
-                    callback?.(null, node_opcua_status_code_1.StatusCodes.BadInternalError);
+                    callback?.(null, StatusCodes.BadInternalError);
                     return;
                 }
             }
@@ -816,48 +812,48 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             throw new Error("Internal error");
         }
         if (!this.canUserWriteAttribute(context, writeValueOptions.attributeId)) {
-            callback(null, node_opcua_status_code_1.StatusCodes.BadUserAccessDenied);
+            callback(null, StatusCodes.BadUserAccessDenied);
             return;
         }
-        const writeValue = writeValueOptions instanceof node_opcua_service_write_1.WriteValue ? writeValueOptions : new node_opcua_service_write_1.WriteValue(writeValueOptions);
-        context = context || session_context_js_1.SessionContext.defaultContext;
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
-        (0, node_opcua_assert_1.assert)(writeValue instanceof node_opcua_service_write_1.WriteValue);
-        (0, node_opcua_assert_1.assert)(writeValue.value instanceof node_opcua_data_value_1.DataValue);
-        (0, node_opcua_assert_1.assert)(writeValue.value?.value instanceof node_opcua_variant_1.Variant);
-        (0, node_opcua_assert_1.assert)(typeof callback === "function");
+        const writeValue = writeValueOptions instanceof WriteValue ? writeValueOptions : new WriteValue(writeValueOptions);
+        context = context || SessionContext.defaultContext;
+        assert(context instanceof SessionContext);
+        assert(writeValue instanceof WriteValue);
+        assert(writeValue.value instanceof DataValue);
+        assert(writeValue.value?.value instanceof Variant);
+        assert(typeof callback === "function");
         // Spec 1.0.2 Part 4 page 58
         // If the SourceTimestamp or the ServerTimestamp is specified, the Server shall
         // use these values.
         // xx _apply_default_timestamps(writeValue.value);
         switch (writeValue.attributeId) {
-            case node_opcua_data_model_1.AttributeIds.Value:
+            case AttributeIds.Value:
                 this.writeValue(context, writeValue.value, writeValue.indexRange, callback);
                 break;
-            case node_opcua_data_model_1.AttributeIds.Historizing:
-                if (writeValue.value?.value.dataType !== node_opcua_variant_1.DataType.Boolean) {
-                    callback(null, node_opcua_status_code_1.StatusCodes.BadTypeMismatch);
+            case AttributeIds.Historizing:
+                if (writeValue.value?.value.dataType !== DataType.Boolean) {
+                    callback(null, StatusCodes.BadTypeMismatch);
                     break;
                 }
-                if (!this.checkPermissionPrivate(context, node_opcua_types_1.PermissionType.WriteHistorizing)) {
-                    callback(null, node_opcua_status_code_1.StatusCodes.BadUserAccessDenied);
+                if (!this.checkPermissionPrivate(context, PermissionType.WriteHistorizing)) {
+                    callback(null, StatusCodes.BadUserAccessDenied);
                     break;
                 }
                 if (!this.canUserWriteHistorizingAttribute(context)) {
-                    callback(null, node_opcua_status_code_1.StatusCodes.BadHistoryOperationUnsupported);
+                    callback(null, StatusCodes.BadHistoryOperationUnsupported);
                     break;
                 }
                 // Historizing is a real, writable attribute of a Variable (Part 3 5.6.2); a node
                 // without an HA Configuration simply cannot honour it right now, which is
                 // BadNotWritable, not BadNotSupported (that would mean the attribute never applies).
                 if (!this.getChildByName("HA Configuration")) {
-                    callback(null, node_opcua_status_code_1.StatusCodes.BadNotWritable);
+                    callback(null, StatusCodes.BadNotWritable);
                     break;
                 }
                 // check if user is allowed to do that !
                 // TODO
                 this.historizing = !!writeValue.value?.value.value; // yes ! indeed !
-                callback(null, node_opcua_status_code_1.StatusCodes.Good);
+                callback(null, StatusCodes.Good);
                 break;
             default:
                 super.writeAttribute(context, writeValue, callback);
@@ -874,23 +870,23 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     checkVariantCompatibility(value) {
         // test dataType
         if (!this._validate_DataType(value.dataType)) {
-            return node_opcua_status_code_1.StatusCodes.BadTypeMismatch;
+            return StatusCodes.BadTypeMismatch;
         }
         try {
             this.verifyVariantCompatibility(value);
         }
         catch (_err) {
-            return node_opcua_status_code_1.StatusCodes.BadTypeMismatch;
+            return StatusCodes.BadTypeMismatch;
         }
-        return node_opcua_status_code_1.StatusCodes.Good;
+        return StatusCodes.Good;
     }
     /**
      * touch the source timestamp of a Variable and cascade up the change
      * to the parent variable if any.
      */
     touchValue(optionalNow) {
-        const now = optionalNow || (0, node_opcua_date_time_1.getCurrentClock)();
-        (0, ua_variable_impl_ext_obj_js_1.propagateTouchValueUpward)(this, now);
+        const now = optionalNow || getCurrentClock();
+        propagateTouchValueUpward(this, now);
     }
     /**
      * bind a variable with a get and set functions.
@@ -1023,24 +1019,24 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             this._historyRead = UAVariableImpl.prototype._historyRead;
         }
         options = options || {};
-        (0, node_opcua_assert_1.assert)(typeof this._timestamped_set_func !== "function", "UAVariable already bound");
-        (0, node_opcua_assert_1.assert)(typeof this._timestamped_get_func !== "function", "UAVariable already bound");
+        assert(typeof this._timestamped_set_func !== "function", "UAVariable already bound");
+        assert(typeof this._timestamped_get_func !== "function", "UAVariable already bound");
         bind_getter.call(this, options);
         bind_setter.call(this, options);
         const _historyRead = options.historyRead;
         if (_historyRead) {
-            (0, node_opcua_assert_1.assert)(typeof this._historyRead !== "function" || this._historyRead === UAVariableImpl.prototype._historyRead);
-            (0, node_opcua_assert_1.assert)(typeof _historyRead === "function");
+            assert(typeof this._historyRead !== "function" || this._historyRead === UAVariableImpl.prototype._historyRead);
+            assert(typeof _historyRead === "function");
             this._historyRead = _historyRead;
-            (0, node_opcua_assert_1.assert)(this._historyRead.length === 6);
+            assert(this._historyRead.length === 6);
         }
         // post conditions
-        (0, node_opcua_assert_1.assert)(typeof this._timestamped_set_func === "function");
-        (0, node_opcua_assert_1.assert)(this._timestamped_set_func?.length === 2, "expecting 2 parameters");
+        assert(typeof this._timestamped_set_func === "function");
+        assert(this._timestamped_set_func?.length === 2, "expecting 2 parameters");
     }
     readValueAsync(context, callback) {
-        (0, node_opcua_assert_1.assert)(typeof callback === "function");
-        context = context || session_context_js_1.SessionContext.defaultContext;
+        assert(typeof callback === "function");
+        context = context || SessionContext.defaultContext;
         this.__waiting_callbacks = this.__waiting_callbacks || [];
         this.__waiting_callbacks.push(callback);
         const _readValueAsync_in_progress = this.__waiting_callbacks.length >= 2;
@@ -1048,18 +1044,18 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             return;
         }
         if (this.isDisposed()) {
-            callback?.(null, new node_opcua_data_value_1.DataValue({ statusCode: node_opcua_status_code_1.StatusCodes.BadNodeIdUnknown }));
+            callback?.(null, new DataValue({ statusCode: StatusCodes.BadNodeIdUnknown }));
             return;
         }
         const readImmediate = (innerCallback) => {
-            (0, node_opcua_assert_1.assert)(this.$dataValue instanceof node_opcua_data_value_1.DataValue);
+            assert(this.$dataValue instanceof DataValue);
             const dataValue = this.readValue(context);
             innerCallback(null, dataValue);
         };
         let func;
         // stamped like the same gates of readValue(): the requested timestamps are expected
         // on a Bad result too (FEAT-34)
-        const answerStatusOnly = (statusCode) => (innerCallback) => innerCallback(null, (0, node_opcua_data_value_1.makeNowDataValue)({ statusCode }));
+        const answerStatusOnly = (statusCode) => (innerCallback) => innerCallback(null, makeNowDataValue({ statusCode }));
         if (context.isAccessRestricted(this)) {
             // same gate as readValue(): a variable bound with a simple get()
             // also gets a refreshFunc, sending every read down the asyncRefresh
@@ -1067,19 +1063,19 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             // through readValue(). Without this check here, a node hardened
             // with AccessRestrictions(EncryptionRequired) answered its value
             // over an unencrypted channel.
-            func = answerStatusOnly(node_opcua_status_code_1.StatusCodes.BadSecurityModeInsufficient);
+            func = answerStatusOnly(StatusCodes.BadSecurityModeInsufficient);
         }
         else if (!this.isReadable(context)) {
-            func = answerStatusOnly(node_opcua_status_code_1.StatusCodes.BadNotReadable);
+            func = answerStatusOnly(StatusCodes.BadNotReadable);
         }
-        else if (!this.checkPermissionPrivate(context, node_opcua_types_1.PermissionType.Read)) {
-            func = answerStatusOnly(node_opcua_status_code_1.StatusCodes.BadUserAccessDenied);
+        else if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
+            func = answerStatusOnly(StatusCodes.BadUserAccessDenied);
         }
         else if (!this.isUserReadable(context)) {
-            func = answerStatusOnly(node_opcua_status_code_1.StatusCodes.BadNotReadable);
+            func = answerStatusOnly(StatusCodes.BadNotReadable);
         }
         else {
-            const clock = (0, node_opcua_date_time_1.getCurrentClock)();
+            const clock = getCurrentClock();
             func = typeof this.refreshFunc === "function" ? this.asyncRefresh.bind(this, clock) : readImmediate;
         }
         const satisfy_callbacks = (err, dataValue) => {
@@ -1097,8 +1093,8 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         catch (err) {
             // c8 ignore next
             if (doDebug) {
-                debugLog(chalk_1.default.red("func readValueAsync has failed "));
-                if (node_util_1.types.isNativeError(err)) {
+                debugLog(chalk.red("func readValueAsync has failed "));
+                if (types.isNativeError(err)) {
                     debugLog(" stack", err.stack);
                 }
             }
@@ -1125,14 +1121,14 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             userAccessLevel: this.userAccessLevel,
             valueRank: this.valueRank
         };
-        const newVariable = (0, base_node_private_js_1._clone)(this, (UAVariableImpl), options, optionalFilter || node_opcua_address_space_base_1.defaultCloneFilter, extraInfo || (0, node_opcua_address_space_base_1.makeDefaultCloneExtraInfo)(this));
+        const newVariable = _clone(this, UAVariableImpl, options, optionalFilter || defaultCloneFilter, extraInfo || makeDefaultCloneExtraInfo(this));
         newVariable.bindVariable();
-        (0, node_opcua_assert_1.assert)(typeof newVariable._timestamped_set_func === "function");
-        (0, node_opcua_assert_1.assert)(newVariable.dataType === this.dataType);
+        assert(typeof newVariable._timestamped_set_func === "function");
+        assert(newVariable.dataType === this.dataType);
         newVariable.$dataValue = this.$dataValue.clone();
         // also bind extension object
         const v = newVariable.$dataValue.value;
-        if (v.dataType === node_opcua_variant_1.DataType.ExtensionObject && v.value && v.arrayType === node_opcua_variant_1.VariantArrayType.Scalar) {
+        if (v.dataType === DataType.ExtensionObject && v.value && v.arrayType === VariantArrayType.Scalar) {
             try {
                 newVariable.bindExtensionObject(newVariable.$dataValue.value.value);
             }
@@ -1152,7 +1148,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
     getDataTypeNode() {
         const addressSpace = this.addressSpace;
         if (this.dataType.isEmpty()) {
-            this.dataType = this.resolveNodeId(node_opcua_variant_1.DataType.Variant);
+            this.dataType = this.resolveNodeId(DataType.Variant);
         }
         const dt = addressSpace.findNode(this.dataType);
         // c8 ignore next
@@ -1178,7 +1174,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             // has not yet been loaded !
             return true;
         }
-        if (dataType.nodeId.namespace === 0 && dataType.nodeId.value === node_opcua_variant_1.DataType.ExtensionObject) {
+        if (dataType.nodeId.namespace === 0 && dataType.nodeId.value === DataType.ExtensionObject) {
             return true;
         }
         const Constructor = addressSpace.getExtensionObjectConstructor(this.dataType);
@@ -1221,7 +1217,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             if (extObj.constructor.name === Constructor.name) {
                 return true;
             }
-            if (extObj instanceof node_opcua_extension_object_1.OpaqueStructure) {
+            if (extObj instanceof OpaqueStructure) {
                 throw new Error("An opaque structure is not expected here");
             }
             // let's verify that the constructor is a sub-class of Constructor
@@ -1271,67 +1267,67 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
      * precondition:
      */
     installExtensionObjectVariables() {
-        (0, ua_variable_impl_ext_obj_js_1._installExtensionObjectBindingOnProperties)(this, { createMissingProp: true });
+        _installExtensionObjectBindingOnProperties(this, { createMissingProp: true });
     }
     /**
 
      * @return {ExtensionObject}
      */
     bindExtensionObjectScalar(optionalExtensionObject, options) {
-        (0, node_opcua_assert_1.assert)(this.valueRank === -1, "expecting an Scalar variable here");
-        return (0, ua_variable_impl_ext_obj_js_1._bindExtensionObject)(this, optionalExtensionObject, options);
+        assert(this.valueRank === -1, "expecting an Scalar variable here");
+        return _bindExtensionObject(this, optionalExtensionObject, options);
     }
     bindExtensionObjectArray(optionalExtensionObject, options) {
-        (0, node_opcua_assert_1.assert)(this.valueRank >= 1, "expecting an Array or a Matrix variable here");
-        return (0, ua_variable_impl_ext_obj_js_1._bindExtensionObjectArrayOrMatrix)(this, optionalExtensionObject, options);
+        assert(this.valueRank >= 1, "expecting an Array or a Matrix variable here");
+        return _bindExtensionObjectArrayOrMatrix(this, optionalExtensionObject, options);
     }
     bindExtensionObject(optionalExtensionObject, options) {
         // coerce to ExtensionObject[] when this.valueRank === 1
         if (optionalExtensionObject &&
             this.valueRank === 1 &&
             !Array.isArray(optionalExtensionObject) &&
-            optionalExtensionObject instanceof node_opcua_extension_object_1.ExtensionObject) {
+            optionalExtensionObject instanceof ExtensionObject) {
             warningLog("bindExtensionObject: coerce to ExtensionObject[] when valueRank === 1 and value is a scalar extension object");
             optionalExtensionObject = [optionalExtensionObject];
         }
         if (optionalExtensionObject) {
             if (Array.isArray(optionalExtensionObject)) {
-                (0, node_opcua_assert_1.assert)(this.valueRank >= 1, "bindExtensionObject: expecting an Array of Matrix variable here");
-                return (0, ua_variable_impl_ext_obj_js_1._bindExtensionObjectArrayOrMatrix)(this, optionalExtensionObject, options);
+                assert(this.valueRank >= 1, "bindExtensionObject: expecting an Array of Matrix variable here");
+                return _bindExtensionObjectArrayOrMatrix(this, optionalExtensionObject, options);
             }
             else {
                 if (this.valueRank !== -1 && this.valueRank !== 0) {
                     throw new Error(`bindExtensionObject: expecting an Scalar variable here but got value rank ${this.valueRank}`);
                 }
-                return (0, ua_variable_impl_ext_obj_js_1._bindExtensionObject)(this, optionalExtensionObject, options);
+                return _bindExtensionObject(this, optionalExtensionObject, options);
             }
         }
-        (0, node_opcua_assert_1.assert)(optionalExtensionObject === undefined || optionalExtensionObject === null);
+        assert(optionalExtensionObject === undefined || optionalExtensionObject === null);
         if (this.valueRank === -1) {
-            return (0, ua_variable_impl_ext_obj_js_1._bindExtensionObject)(this, undefined, options);
+            return _bindExtensionObject(this, undefined, options);
         }
         else if (this.valueRank === 1) {
-            return (0, ua_variable_impl_ext_obj_js_1._bindExtensionObjectArrayOrMatrix)(this, undefined, options);
+            return _bindExtensionObjectArrayOrMatrix(this, undefined, options);
         }
         else if (this.valueRank > 1) {
-            return (0, ua_variable_impl_ext_obj_js_1._bindExtensionObjectArrayOrMatrix)(this, undefined, options);
+            return _bindExtensionObjectArrayOrMatrix(this, undefined, options);
         }
         //  unsupported case ...
         return null;
     }
     updateExtensionObjectPartial(partialExtensionObject) {
-        (0, ua_variable_impl_ext_obj_js_1.setExtensionObjectPartialValue)(this, partialExtensionObject);
+        setExtensionObjectPartialValue(this, partialExtensionObject);
         return this.$extensionObject;
     }
     incrementExtensionObjectPartial(path) {
         const extensionObject = this.readValue().value.value;
-        const partialData = (0, ua_variable_impl_ext_obj_js_1.extractPartialData)(path, extensionObject);
-        (0, ua_variable_impl_ext_obj_js_1.incrementElement)(path, partialData);
-        (0, ua_variable_impl_ext_obj_js_1.setExtensionObjectPartialValue)(this, partialData);
+        const partialData = extractPartialData(path, extensionObject);
+        incrementElement(path, partialData);
+        setExtensionObjectPartialValue(this, partialData);
     }
     toString() {
-        const options = new base_node_private_js_1.ToStringBuilder();
-        base_node_private_js_1.UAVariable_toString.call(this, options);
+        const options = new ToStringBuilder();
+        UAVariable_toString.call(this, options);
         return options.toString();
     }
     toJSON() {
@@ -1341,7 +1337,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             const dv = this.$dataValue;
             if (dv) {
                 statusCode = dv.statusCode?.toString();
-                if (dv.value && !(dv.value.value instanceof node_opcua_extension_object_1.OpaqueStructure)) {
+                if (dv.value && !(dv.value.value instanceof OpaqueStructure)) {
                     value = dv.value.value;
                 }
             }
@@ -1355,13 +1351,13 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             dataType: this.dataType?.toString(),
             valueRank: this.valueRank,
             arrayDimensions: this.arrayDimensions,
-            accessLevel: node_opcua_data_model_1.AccessLevelFlag[this.accessLevel],
+            accessLevel: AccessLevelFlag[this.accessLevel],
             statusCode,
             value
         };
     }
     [Symbol.for("nodejs.util.inspect.custom")](depth, inspectOptions) {
-        const c = inspectOptions?.colors === false ? plainChalk : chalk_1.default;
+        const c = inspectOptions?.colors === false ? plainChalk : chalk;
         const typeName = this.typeDefinitionObj?.browseName.toString() ?? "?";
         const displayName = this.displayName.length ? this.displayName.map((d) => d.text).join(" | ") : "";
         if (depth !== null && depth <= 0) {
@@ -1378,7 +1374,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
                 if (dv.value &&
                     dv.value.value !== undefined &&
                     dv.value.value !== null &&
-                    !(dv.value.value instanceof node_opcua_extension_object_1.OpaqueStructure)) {
+                    !(dv.value.value instanceof OpaqueStructure)) {
                     const v = dv.value.value;
                     valueStr = typeof v === "object" ? Object.prototype.toString.call(v) : String(v);
                     if (valueStr.length > 80)
@@ -1394,8 +1390,8 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             c.yellow("  typeDefinition : ") + typeName,
             c.yellow("  displayName    : ") + displayName,
             c.yellow("  dataType       : ") + dt,
-            c.yellow("  valueRank      : ") + (0, base_node_private_js_1.valueRankToString)(this.valueRank),
-            c.yellow("  accessLevel    : ") + node_opcua_data_model_1.AccessLevelFlag[this.accessLevel]
+            c.yellow("  valueRank      : ") + valueRankToString(this.valueRank),
+            c.yellow("  accessLevel    : ") + AccessLevelFlag[this.accessLevel]
         ];
         if (this.arrayDimensions?.length) {
             lines.push(c.yellow("  arrayDimensions: ") + JSON.stringify(this.arrayDimensions));
@@ -1412,10 +1408,10 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         return lines.join("\n");
     }
     historyRead(context, historyReadDetails, indexRange, dataEncoding, continuationData, callback) {
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
-        (0, node_opcua_assert_1.assert)(typeof callback === "function");
+        assert(context instanceof SessionContext);
+        assert(typeof callback === "function");
         if (typeof this._historyRead !== "function") {
-            callback?.(null, new node_opcua_types_1.HistoryReadResult({ statusCode: node_opcua_status_code_1.StatusCodes.BadNotReadable }));
+            callback?.(null, new HistoryReadResult({ statusCode: StatusCodes.BadNotReadable }));
             return;
         }
         this._historyRead(context, historyReadDetails, indexRange, dataEncoding, continuationData, callback);
@@ -1428,20 +1424,20 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         throw new Error("");
     }
     _historyRead(context, _historyReadDetails, _indexRange, _dataEncoding, _continuationData, callback) {
-        if (!this.checkPermissionPrivate(context, node_opcua_types_1.PermissionType.ReadHistory)) {
-            const result = new node_opcua_types_1.HistoryReadResult({
-                statusCode: node_opcua_status_code_1.StatusCodes.BadUserAccessDenied
+        if (!this.checkPermissionPrivate(context, PermissionType.ReadHistory)) {
+            const result = new HistoryReadResult({
+                statusCode: StatusCodes.BadUserAccessDenied
             });
             callback(null, result);
         }
         if (!this.canUserReadHistory(context)) {
-            const result = new node_opcua_types_1.HistoryReadResult({
-                statusCode: node_opcua_status_code_1.StatusCodes.BadHistoryOperationUnsupported
+            const result = new HistoryReadResult({
+                statusCode: StatusCodes.BadHistoryOperationUnsupported
             });
             callback(null, result);
         }
-        const result = new node_opcua_types_1.HistoryReadResult({
-            statusCode: node_opcua_status_code_1.StatusCodes.BadHistoryOperationUnsupported
+        const result = new HistoryReadResult({
+            statusCode: StatusCodes.BadHistoryOperationUnsupported
         });
         callback(null, result);
     }
@@ -1462,26 +1458,26 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         throw new Error("");
     }
     _validate_DataType(variantDataType) {
-        return (0, validate_data_type_correctness_js_1.validateDataTypeCorrectness)(this.addressSpace, this.dataType, variantDataType, /* allow Nulls */ false, this.nodeId);
+        return validateDataTypeCorrectness(this.addressSpace, this.dataType, variantDataType, /* allow Nulls */ false, this.nodeId);
     }
     _internal_set_value(value) {
-        if (value.dataType !== node_opcua_variant_1.DataType.Null) {
+        if (value.dataType !== DataType.Null) {
             this.verifyVariantCompatibility(value);
         }
         this.$dataValue.value = value;
     }
     _internal_set_dataValue(dataValue, indexRange) {
-        (0, node_opcua_assert_1.assert)(dataValue, "expecting a dataValue");
-        (0, node_opcua_assert_1.assert)(dataValue instanceof node_opcua_data_value_1.DataValue, "expecting dataValue to be a DataValue");
-        (0, node_opcua_assert_1.assert)(dataValue !== this.$dataValue, "expecting dataValue to be different from previous DataValue instance");
+        assert(dataValue, "expecting a dataValue");
+        assert(dataValue instanceof DataValue, "expecting dataValue to be a DataValue");
+        assert(dataValue !== this.$dataValue, "expecting dataValue to be different from previous DataValue instance");
         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
-        if (dataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Matrix) {
+        /* c8 ignore next */
+        if (dataValue.value.arrayType === VariantArrayType.Matrix) {
             if (!dataValue.value.dimensions) {
                 throw new Error("missing dimensions: a Matrix Variant needs a dimension");
             }
@@ -1491,7 +1487,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             }
         }
         // c8 ignore next
-        if (dataValue.value.dataType === node_opcua_variant_1.DataType.ExtensionObject) {
+        if (dataValue.value.dataType === DataType.ExtensionObject) {
             // c8 ignore next
             if (!this.checkExtensionObjectIsCorrect(dataValue.value.value)) {
                 warningLog(dataValue.toString());
@@ -1505,34 +1501,34 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
      * @private
      */
     _inner_replace_dataValue(dataValue, indexRange) {
-        (0, node_opcua_assert_1.assert)(this.$dataValue.value instanceof node_opcua_variant_1.Variant);
+        assert(this.$dataValue.value instanceof Variant);
         const old_dataValue = this.$dataValue.clone();
-        if (this.$$extensionObjectArray && dataValue.value.arrayType !== node_opcua_variant_1.VariantArrayType.Scalar) {
+        if (this.$$extensionObjectArray && dataValue.value.arrayType !== VariantArrayType.Scalar) {
             // we have a bounded array or matrix
-            (0, node_opcua_assert_1.assert)(Array.isArray(dataValue.value.value));
+            assert(Array.isArray(dataValue.value.value));
             if (this.$$extensionObjectArray !== this.$dataValue.value.value) {
                 throw new Error("internal error");
             }
             this.$$extensionObjectArray = dataValue.value.value;
             this.$dataValue.value.value = dataValue.value.value;
-            this.$dataValue.statusCode = dataValue.statusCode || node_opcua_status_code_1.StatusCodes.Good;
+            this.$dataValue.statusCode = dataValue.statusCode || StatusCodes.Good;
             this.$dataValue.serverTimestamp = dataValue.serverTimestamp;
             this.$dataValue.serverPicoseconds = dataValue.serverPicoseconds;
             this.$dataValue.sourceTimestamp = dataValue.sourceTimestamp;
             this.$dataValue.sourcePicoseconds = dataValue.sourcePicoseconds;
         }
-        else if (this._basicDataType === node_opcua_variant_1.DataType.ExtensionObject &&
+        else if (this._basicDataType === DataType.ExtensionObject &&
             this.valueRank === -1 &&
             this.$set_ExtensionObject &&
-            dataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Scalar) {
+            dataValue.value.arrayType === VariantArrayType.Scalar) {
             // the entire extension object is changed.
-            this.$dataValue.statusCode = this.$dataValue.statusCode || node_opcua_status_code_1.StatusCodes.Good;
-            const preciseClock = (0, node_opcua_date_time_1.coerceClock)(this.$dataValue.sourceTimestamp, this.$dataValue.sourcePicoseconds);
+            this.$dataValue.statusCode = this.$dataValue.statusCode || StatusCodes.Good;
+            const preciseClock = coerceClock(this.$dataValue.sourceTimestamp, this.$dataValue.sourcePicoseconds);
             this.$set_ExtensionObject(dataValue.value.value, preciseClock, new Set());
         }
         else {
             this.$dataValue = dataValue;
-            this.$dataValue.statusCode = this.$dataValue.statusCode || node_opcua_status_code_1.StatusCodes.Good;
+            this.$dataValue.statusCode = this.$dataValue.statusCode || StatusCodes.Good;
         }
         // repair missing timestamps
         const now = new Date();
@@ -1544,7 +1540,7 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             this.$dataValue.sourceTimestamp = old_dataValue.sourceTimestamp || now;
             this.$dataValue.sourcePicoseconds = old_dataValue.sourcePicoseconds || 0;
         }
-        if (!(0, node_opcua_data_value_1.sameDataValue)(old_dataValue, dataValue)) {
+        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
@@ -1552,18 +1548,18 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
             // ... 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()) {
-                (0, semantics_changed_js_1.notifySemanticsChangedIfNeeded)(this);
+                notifySemanticsChangedIfNeeded(this);
             }
-            if (this.getBasicDataType() === node_opcua_variant_1.DataType.ExtensionObject) {
-                const preciseClock = (0, node_opcua_date_time_1.coerceClock)(this.$dataValue.sourceTimestamp, this.$dataValue.sourcePicoseconds);
+            if (this.getBasicDataType() === DataType.ExtensionObject) {
+                const preciseClock = coerceClock(this.$dataValue.sourceTimestamp, this.$dataValue.sourcePicoseconds);
                 const cache = new Set();
                 if (this.$$extensionObjectArray) {
                     this.touchValue(preciseClock);
-                    (0, ua_variable_impl_ext_obj_js_1.propagateTouchValueDownwardArray)(this, preciseClock, cache);
+                    propagateTouchValueDownwardArray(this, preciseClock, cache);
                 }
                 else {
                     this.touchValue(preciseClock);
-                    (0, ua_variable_impl_ext_obj_js_1.propagateTouchValueDownward)(this, preciseClock, cache);
+                    propagateTouchValueDownward(this, preciseClock, cache);
                 }
             }
             else {
@@ -1572,117 +1568,119 @@ class UAVariableImpl extends base_node_impl_js_1.BaseNodeImpl {
         }
     }
     _conditionRefresh(_cache) {
-        apply_condition_refresh_js_1.apply_condition_refresh.call(this, _cache);
+        apply_condition_refresh.call(this, _cache);
     }
     handle_semantic_changed(_dataValue) {
         this.semantic_version = this.semantic_version + 1;
         this.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);
     }
     _readDataType() {
-        (0, node_opcua_assert_1.assert)(this.dataType instanceof node_opcua_nodeid_1.NodeId);
+        assert(this.dataType instanceof NodeId);
         const options = {
-            statusCode: node_opcua_status_code_1.StatusCodes.Good,
+            statusCode: StatusCodes.Good,
             value: {
-                dataType: node_opcua_variant_1.DataType.NodeId,
+                dataType: DataType.NodeId,
                 value: this.dataType
             }
         };
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
     _readValueRank() {
-        (0, node_opcua_assert_1.assert)(typeof this.valueRank === "number");
+        assert(typeof this.valueRank === "number");
         const options = {
-            statusCode: node_opcua_status_code_1.StatusCodes.Good,
-            value: { dataType: node_opcua_variant_1.DataType.Int32, value: this.valueRank }
+            statusCode: StatusCodes.Good,
+            value: { dataType: DataType.Int32, value: this.valueRank }
         };
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
     _readArrayDimensions() {
-        (0, node_opcua_assert_1.assert)(Array.isArray(this.arrayDimensions) || this.arrayDimensions === null);
-        (0, node_opcua_assert_1.assert)(!this.arrayDimensions || this.valueRank > 0, "arrayDimension must be null if valueRank <0");
+        assert(Array.isArray(this.arrayDimensions) || this.arrayDimensions === null);
+        assert(!this.arrayDimensions || this.valueRank > 0, "arrayDimension must be null if valueRank <0");
         const options = {
-            statusCode: node_opcua_status_code_1.StatusCodes.Good,
-            value: { dataType: node_opcua_variant_1.DataType.UInt32, arrayType: node_opcua_variant_1.VariantArrayType.Array, value: this.arrayDimensions }
+            statusCode: StatusCodes.Good,
+            value: { dataType: DataType.UInt32, arrayType: VariantArrayType.Array, value: this.arrayDimensions }
         };
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
     _readAccessLevel(context) {
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
+        assert(context instanceof SessionContext);
         const options = {
-            statusCode: node_opcua_status_code_1.StatusCodes.Good,
-            value: { dataType: node_opcua_variant_1.DataType.Byte, value: (0, node_opcua_data_model_1.convertAccessLevelFlagToByte)(this.accessLevel) }
+            statusCode: StatusCodes.Good,
+            value: { dataType: DataType.Byte, value: convertAccessLevelFlagToByte(this.accessLevel) }
         };
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
     _readAccessLevelEx(context) {
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
+        assert(context instanceof SessionContext);
         const options = {
-            statusCode: node_opcua_status_code_1.StatusCodes.Good,
+            statusCode: StatusCodes.Good,
             // Extra flags are not supported yet. to do:
-            value: { dataType: node_opcua_variant_1.DataType.UInt32, value: (0, node_opcua_data_model_1.convertAccessLevelFlagToByte)(this.accessLevel) }
+            value: { dataType: DataType.UInt32, value: convertAccessLevelFlagToByte(this.accessLevel) }
         };
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
     _readUserAccessLevel(context) {
-        (0, node_opcua_assert_1.assert)(context instanceof session_context_js_1.SessionContext);
+        assert(context instanceof SessionContext);
         const effectiveUserAccessLevel = _calculateEffectiveUserAccessLevelFromPermission(this, context, this.userAccessLevel);
         const options = {
             value: {
-                dataType: node_opcua_variant_1.DataType.Byte,
-                statusCode: node_opcua_status_code_1.StatusCodes.Good,
-                value: (0, node_opcua_data_model_1.convertAccessLevelFlagToByte)(effectiveUserAccessLevel)
+                dataType: DataType.Byte,
+                statusCode: StatusCodes.Good,
+                value: convertAccessLevelFlagToByte(effectiveUserAccessLevel)
             }
         };
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
     _readMinimumSamplingInterval() {
         // expect a Duration => Double
         const options = {};
         if (this.minimumSamplingInterval === undefined) {
-            options.statusCode = node_opcua_status_code_1.StatusCodes.BadAttributeIdInvalid;
+            options.statusCode = StatusCodes.BadAttributeIdInvalid;
         }
         else {
-            options.value = { dataType: node_opcua_variant_1.DataType.Double, value: this.minimumSamplingInterval };
-            options.statusCode = node_opcua_status_code_1.StatusCodes.Good;
+            options.value = { dataType: DataType.Double, value: this.minimumSamplingInterval };
+            options.statusCode = StatusCodes.Good;
         }
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
     _readHistorizing() {
-        (0, node_opcua_assert_1.assert)(typeof this.historizing === "boolean");
+        assert(typeof this.historizing === "boolean");
         const options = {
-            statusCode: node_opcua_status_code_1.StatusCodes.Good,
-            value: { dataType: node_opcua_variant_1.DataType.Boolean, value: !!this.historizing }
+            statusCode: StatusCodes.Good,
+            value: { dataType: DataType.Boolean, value: !!this.historizing }
         };
-        return new node_opcua_data_value_1.DataValue(options);
+        return new DataValue(options);
     }
 }
-exports.UAVariableImpl = UAVariableImpl;
-const thenify_ex_1 = require("thenify-ex");
-UAVariableImpl.prototype.asyncRefresh = (0, thenify_ex_1.withCallback)(UAVariableImpl.prototype.asyncRefresh);
-UAVariableImpl.prototype.writeValue = (0, thenify_ex_1.withCallback)(UAVariableImpl.prototype.writeValue);
-UAVariableImpl.prototype.writeAttribute = (0, thenify_ex_1.withCallback)(UAVariableImpl.prototype.writeAttribute);
-UAVariableImpl.prototype.historyRead = (0, thenify_ex_1.withCallback)(UAVariableImpl.prototype.historyRead);
-UAVariableImpl.prototype.readValueAsync = (0, thenify_ex_1.withCallback)(UAVariableImpl.prototype.readValueAsync);
+import { withCallback } from "thenify-ex";
+UAVariableImpl.prototype.asyncRefresh = withCallback(UAVariableImpl.prototype.asyncRefresh);
+UAVariableImpl.prototype.writeValue = withCallback(UAVariableImpl.prototype.writeValue);
+UAVariableImpl.prototype.writeAttribute = withCallback(UAVariableImpl.prototype.writeAttribute);
+UAVariableImpl.prototype.historyRead = withCallback(UAVariableImpl.prototype.historyRead);
+UAVariableImpl.prototype.readValueAsync = withCallback(UAVariableImpl.prototype.readValueAsync);
 function check_valid_array(dataType, array) {
     if (Array.isArray(array)) {
         return true;
     }
     switch (dataType) {
-        case node_opcua_variant_1.DataType.Double:
+        case DataType.Double:
             return array instanceof Float64Array;
-        case node_opcua_variant_1.DataType.Float:
+        case DataType.Float:
             return array instanceof Float32Array;
-        case node_opcua_variant_1.DataType.Int32:
+        case DataType.Int32:
             return array instanceof Int32Array;
-        case node_opcua_variant_1.DataType.Int16:
+        case DataType.Int16:
             return array instanceof Int16Array;
-        case node_opcua_variant_1.DataType.SByte:
+        case DataType.SByte:
             return array instanceof Int8Array;
-        case node_opcua_variant_1.DataType.UInt32:
+        case DataType.UInt32:
             return array instanceof Uint32Array;
-        case node_opcua_variant_1.DataType.UInt16:
+        case DataType.UInt16:
             return array instanceof Uint16Array;
-        case node_opcua_variant_1.DataType.Byte:
+        case DataType.Byte:
             return array instanceof Uint8Array || array instanceof Buffer;
     }
     return false;
@@ -1719,13 +1717,13 @@ function _calculateEffectiveUserAccessLevelFromPermission(node, context, userAcc
     }
     userAccessLevel = node.userAccessLevel === undefined ? node.accessLevel : node.userAccessLevel & node.accessLevel;
     if (context.checkPermission) {
-        (0, node_opcua_assert_1.assert)(context.checkPermission instanceof Function);
-        userAccessLevel = __adjustFlag(node_opcua_types_1.PermissionType.Read, node_opcua_data_model_1.AccessLevelFlag.CurrentRead, userAccessLevel);
-        userAccessLevel = __adjustFlag(node_opcua_types_1.PermissionType.Write, node_opcua_data_model_1.AccessLevelFlag.CurrentWrite, userAccessLevel);
-        userAccessLevel = __adjustFlag(node_opcua_types_1.PermissionType.Write, node_opcua_data_model_1.AccessLevelFlag.StatusWrite, userAccessLevel);
-        userAccessLevel = __adjustFlag(node_opcua_types_1.PermissionType.Write, node_opcua_data_model_1.AccessLevelFlag.TimestampWrite, userAccessLevel);
-        userAccessLevel = __adjustFlag(node_opcua_types_1.PermissionType.ReadHistory, node_opcua_data_model_1.AccessLevelFlag.HistoryRead, userAccessLevel);
-        userAccessLevel = __adjustFlag(node_opcua_types_1.PermissionType.DeleteHistory, node_opcua_data_model_1.AccessLevelFlag.HistoryWrite, userAccessLevel);
+        assert(context.checkPermission instanceof Function);
+        userAccessLevel = __adjustFlag(PermissionType.Read, AccessLevelFlag.CurrentRead, userAccessLevel);
+        userAccessLevel = __adjustFlag(PermissionType.Write, AccessLevelFlag.CurrentWrite, userAccessLevel);
+        userAccessLevel = __adjustFlag(PermissionType.Write, AccessLevelFlag.StatusWrite, userAccessLevel);
+        userAccessLevel = __adjustFlag(PermissionType.Write, AccessLevelFlag.TimestampWrite, userAccessLevel);
+        userAccessLevel = __adjustFlag(PermissionType.ReadHistory, AccessLevelFlag.HistoryRead, userAccessLevel);
+        userAccessLevel = __adjustFlag(PermissionType.DeleteHistory, AccessLevelFlag.HistoryWrite, userAccessLevel);
         return userAccessLevel;
     }
     else {
@@ -1736,16 +1734,16 @@ function adjustVariant2(variant) {
     // convert Variant( Scalar|ByteString) =>  Variant(Array|ByteArray)
     const _addressSpace = this.addressSpace;
     const basicType = this.getBasicDataType();
-    variant = (0, node_opcua_variant_1.adjustVariant)(variant, this.valueRank, basicType);
+    variant = adjustVariant(variant, this.valueRank, basicType);
     return variant;
 }
 function _not_writable_timestamped_set_func(dataValue, callback) {
-    (0, node_opcua_assert_1.assert)(dataValue instanceof node_opcua_data_value_1.DataValue);
-    callback(null, node_opcua_status_code_1.StatusCodes.BadNotWritable, null);
+    assert(dataValue instanceof DataValue);
+    callback(null, StatusCodes.BadNotWritable, null);
 }
 function _default_writable_timestamped_set_func(dataValue, callback) {
-    (0, node_opcua_assert_1.assert)(dataValue instanceof node_opcua_data_value_1.DataValue);
-    callback(null, node_opcua_status_code_1.StatusCodes.Good, dataValue);
+    assert(dataValue instanceof DataValue);
+    callback(null, StatusCodes.Good, dataValue);
 }
 function turn_sync_to_async(f, numberOfArgs) {
     if (f.length <= numberOfArgs) {
@@ -1775,24 +1773,24 @@ function turn_sync_to_async(f, numberOfArgs) {
         };
     }
     else {
-        (0, node_opcua_assert_1.assert)(f.length === numberOfArgs + 1);
+        assert(f.length === numberOfArgs + 1);
         return f;
     }
 }
 const _default_minimumSamplingInterval = 1000;
 function coerceDataValue(dataValue) {
-    if (dataValue instanceof node_opcua_data_value_1.DataValue) {
+    if (dataValue instanceof DataValue) {
         return dataValue;
     }
-    return new node_opcua_data_value_1.DataValue(dataValue);
+    return new DataValue(dataValue);
 }
 // variation #3 :
 function _Variable_bind_with_async_refresh(options) {
-    (0, node_opcua_assert_1.assert)(this instanceof UAVariableImpl);
-    (0, node_opcua_assert_1.assert)(typeof options.refreshFunc === "function");
-    (0, node_opcua_assert_1.assert)(!options.get, "a getter shall not be specified when refreshFunc is set");
-    (0, node_opcua_assert_1.assert)(!options.timestamped_get, "a getter shall not be specified when refreshFunc is set");
-    (0, node_opcua_assert_1.assert)(!this.refreshFunc);
+    assert(this instanceof UAVariableImpl);
+    assert(typeof options.refreshFunc === "function");
+    assert(!options.get, "a getter shall not be specified when refreshFunc is set");
+    assert(!options.timestamped_get, "a getter shall not be specified when refreshFunc is set");
+    assert(!this.refreshFunc);
     this.refreshFunc = options.refreshFunc;
     /*
     // TO DO : REVISIT THIS ASSUMPTION
@@ -1808,10 +1806,10 @@ function _Variable_bind_with_async_refresh(options) {
 // variation 2
 function _Variable_bind_with_timestamped_get(options) {
     /* jshint validthis: true */
-    (0, node_opcua_assert_1.assert)(this instanceof UAVariableImpl);
-    (0, node_opcua_assert_1.assert)(typeof options.timestamped_get === "function");
-    (0, node_opcua_assert_1.assert)(!options.get, "should not specify 'get' when 'timestamped_get' exists ");
-    (0, node_opcua_assert_1.assert)(!this._timestamped_get_func);
+    assert(this instanceof UAVariableImpl);
+    assert(typeof options.timestamped_get === "function");
+    assert(!options.get, "should not specify 'get' when 'timestamped_get' exists ");
+    assert(!this._timestamped_get_func);
     const async_refresh_func = (callback) => {
         Promise.resolve(this._timestamped_get_func.call(this))
             .then((dataValue) => callback(null, dataValue))
@@ -1828,8 +1826,8 @@ function _Variable_bind_with_timestamped_get(options) {
         const dataValue_verify = timestamped_get.call(pThis);
         // dataValue_verify should be a DataValue or a Promise
         /* c8 ignore next */
-        if (!(dataValue_verify instanceof node_opcua_data_value_1.DataValue) && typeof dataValue_verify.then !== "function") {
-            errorLog(chalk_1.default.red(" Bind variable error: "), " the timestamped_get function must return a DataValue or a Promise<DataValue>" +
+        if (!(dataValue_verify instanceof DataValue) && typeof dataValue_verify.then !== "function") {
+            errorLog(chalk.red(" Bind variable error: "), " the timestamped_get function must return a DataValue or a Promise<DataValue>" +
                 "\n value_check.constructor.name ", dataValue_verify ? dataValue_verify.constructor.name : "null");
             throw new Error(" Bind variable error: " + " the timestamped_get function must return a DataValue");
         }
@@ -1845,31 +1843,31 @@ function _Variable_bind_with_timestamped_get(options) {
 }
 // variation 1
 function _Variable_bind_with_simple_get(options) {
-    (0, node_opcua_assert_1.assert)(this instanceof UAVariableImpl);
-    (0, node_opcua_assert_1.assert)(typeof options.get === "function", "should specify get function");
-    (0, node_opcua_assert_1.assert)(options.get?.length === 0, "get function should not have arguments");
-    (0, node_opcua_assert_1.assert)(!options.timestamped_get, "should not specify a timestamped_get function when get is specified");
-    (0, node_opcua_assert_1.assert)(!this._timestamped_get_func);
-    (0, node_opcua_assert_1.assert)(!this._get_func);
+    assert(this instanceof UAVariableImpl);
+    assert(typeof options.get === "function", "should specify get function");
+    assert(options.get?.length === 0, "get function should not have arguments");
+    assert(!options.timestamped_get, "should not specify a timestamped_get function when get is specified");
+    assert(!this._timestamped_get_func);
+    assert(!this._get_func);
     this._get_func = options.get;
     const timestamped_get_func_from__Variable_bind_with_simple_get = () => {
         const value = this._get_func();
         /* c8 ignore next */
         if (!is_Variant_or_StatusCode(value)) {
-            errorLog(chalk_1.default.red(" Bind variable error: "), " : the getter must return a Variant or a StatusCode" + "\nvalue_check.constructor.name ", value ? value.constructor.name : "null");
+            errorLog(chalk.red(" Bind variable error: "), " : the getter must return a Variant or a StatusCode" + "\nvalue_check.constructor.name ", value ? value.constructor.name : "null");
             throw new Error(" bindVariable : the value getter function returns a invalid result ( expecting a Variant or a StatusCode !!!");
         }
         if (is_StatusCode(value)) {
-            return new node_opcua_data_value_1.DataValue({ statusCode: value });
+            return new DataValue({ statusCode: value });
         }
         else {
-            if (!this.$dataValue?.statusCode.isGoodish() || !(0, node_opcua_variant_1.sameVariant)(this.$dataValue.value, value)) {
+            if (!this.$dataValue?.statusCode.isGoodish() || !sameVariant(this.$dataValue.value, value)) {
                 // rebuilding artificially timestamps with current clock as they are not provided
                 // by the underlying getter function
-                const { timestamp: sourceTimestamp, picoseconds: sourcePicoseconds } = (0, node_opcua_date_time_1.getCurrentClock)();
+                const { timestamp: sourceTimestamp, picoseconds: sourcePicoseconds } = getCurrentClock();
                 const serverTimestamp = sourceTimestamp;
                 const serverPicoseconds = sourcePicoseconds;
-                this._inner_replace_dataValue(new node_opcua_data_value_1.DataValue({ value, sourceTimestamp, sourcePicoseconds, serverTimestamp, serverPicoseconds }));
+                this._inner_replace_dataValue(new DataValue({ value, sourceTimestamp, sourcePicoseconds, serverTimestamp, serverPicoseconds }));
             }
             return this.$dataValue;
         }
@@ -1880,36 +1878,36 @@ function _Variable_bind_with_simple_get(options) {
     });
 }
 function _Variable_bind_with_simple_set(options) {
-    (0, node_opcua_assert_1.assert)(this instanceof UAVariableImpl);
-    (0, node_opcua_assert_1.assert)(typeof options.set === "function", "should specify set function");
-    (0, node_opcua_assert_1.assert)(!options.timestamped_set, "should not specify a timestamped_set function");
-    (0, node_opcua_assert_1.assert)(!this._timestamped_set_func);
-    (0, node_opcua_assert_1.assert)(!this._set_func);
+    assert(this instanceof UAVariableImpl);
+    assert(typeof options.set === "function", "should specify set function");
+    assert(!options.timestamped_set, "should not specify a timestamped_set function");
+    assert(!this._timestamped_set_func);
+    assert(!this._set_func);
     //
     const set_func = turn_sync_to_async(options.set, 1);
     this._set_func = set_func;
-    (0, node_opcua_assert_1.assert)(set_func.length === 2, " set function must have 2 arguments ( variant, callback)");
+    assert(set_func.length === 2, " set function must have 2 arguments ( variant, callback)");
     this._timestamped_set_func = (timestamped_value, callback) => {
-        (0, node_opcua_assert_1.assert)(timestamped_value instanceof node_opcua_data_value_1.DataValue);
+        assert(timestamped_value instanceof DataValue);
         set_func.call(this, timestamped_value.value, (err, statusCode) => {
             // c8 ignore next
             if (!err && !statusCode) {
-                errorLog(chalk_1.default.red("UAVariable Binding Error _set_func must return a StatusCode, check the bindVariable parameters"));
-                errorLog(chalk_1.default.yellow("StatusCode.Good is assumed"));
-                return callback(err, node_opcua_status_code_1.StatusCodes.Good, timestamped_value);
+                errorLog(chalk.red("UAVariable Binding Error _set_func must return a StatusCode, check the bindVariable parameters"));
+                errorLog(chalk.yellow("StatusCode.Good is assumed"));
+                return callback(err, StatusCodes.Good, timestamped_value);
             }
             if (statusCode?.isNotGood()) {
                 // record the value but still record the statusCode !
                 timestamped_value.statusCode = statusCode;
             }
-            callback(err, statusCode ?? node_opcua_status_code_1.StatusCodes.BadInternalError, timestamped_value);
+            callback(err, statusCode ?? StatusCodes.BadInternalError, timestamped_value);
         });
     };
 }
 function _Variable_bind_with_timestamped_set(options) {
-    (0, node_opcua_assert_1.assert)(options.timestamped_set.length === 2 || options.timestamped_set.length === 1, "timestamped_set must have 2 parameters  timestamped_set: function(dataValue,callback){} or one paramater  timestamped_set: function(dataValue): Promise<StatusCode>{}");
-    (0, node_opcua_assert_1.assert)(!options.set, "should not specify set when timestamped_set_func exists ");
-    this._timestamped_set_func = (0, multiform_func_js_1.convertToCallbackFunction1)(options.timestamped_set);
+    assert(options.timestamped_set.length === 2 || options.timestamped_set.length === 1, "timestamped_set must have 2 parameters  timestamped_set: function(dataValue,callback){} or one paramater  timestamped_set: function(dataValue): Promise<StatusCode>{}");
+    assert(!options.set, "should not specify set when timestamped_set_func exists ");
+    this._timestamped_set_func = convertToCallbackFunction1(options.timestamped_set);
 }
 function bind_setter(options) {
     if (options.set && typeof options.set === "function") {
@@ -1923,7 +1921,7 @@ function bind_setter(options) {
     }
     else if (typeof options.timestamped_set === "function") {
         // variation 2
-        (0, node_opcua_assert_1.assert)(typeof options.timestamped_get === "function", "timestamped_set must be used with timestamped_get ");
+        assert(typeof options.timestamped_get === "function", "timestamped_set must be used with timestamped_get ");
         _Variable_bind_with_timestamped_set.call(this, {
             set: undefined,
             timestamped_set: options.timestamped_set
@@ -1964,7 +1962,7 @@ function bind_getter(options) {
         _Variable_bind_with_async_refresh.call(this, { refreshFunc: options.refreshFunc });
     }
     else {
-        (0, node_opcua_assert_1.assert)(!Object.hasOwn(options, "set"), "getter is missing : a getter must be provided if a setter is provided");
+        assert(!Object.hasOwn(options, "set"), "getter is missing : a getter must be provided if a setter is provided");
         // xx bind_variant.call(this,options);
         if (options.dataType !== undefined) {
             // if (options.dataType !== DataType.ExtensionObject) {
@@ -1973,7 +1971,7 @@ function bind_getter(options) {
         }
     }
 }
-class UAVariableImplT extends UAVariableImpl {
+export class UAVariableImplT extends UAVariableImpl {
     readValue(context, indexRange, dataEncoding) {
         return super.readValue(context, indexRange, dataEncoding);
     }
@@ -1997,18 +1995,17 @@ class UAVariableImplT extends UAVariableImpl {
         return super.writeValue(context, dataValue, indexRangeOrCallback, callback);
     }
 }
-exports.UAVariableImplT = UAVariableImplT;
 function changeUAVariableDataType(uaVariable, newDataType, valueLike) {
-    let value = valueLike ? (valueLike instanceof node_opcua_variant_1.Variant ? valueLike : new node_opcua_variant_1.Variant(valueLike)) : null;
+    let value = valueLike ? (valueLike instanceof Variant ? valueLike : new Variant(valueLike)) : null;
     const addressSpace = uaVariable.addressSpace;
     const newDataTypeNode = addressSpace.findNode(newDataType);
     // c8 ignore next
-    if (!newDataTypeNode || !(newDataTypeNode instanceof ua_data_type_impl_js_1.UADataTypeImpl)) {
+    if (!newDataTypeNode || !(newDataTypeNode instanceof UADataTypeImpl)) {
         throw new Error(`Cannot find newDataTypeNode ${newDataType.toString()}`);
     }
     const newBaseDataType = newDataTypeNode.basicDataType;
     // c8 ignore next
-    if (newBaseDataType === node_opcua_variant_1.DataType.Null) {
+    if (newBaseDataType === DataType.Null) {
         throw new Error("newDataTypeNode must be a DataType");
     }
     if (!value) {