node-opcua-address-space 2.186.17 → 2.187.1

package/impl/ua_variable_impl.ts

@@ -135,10 +135,6 @@ function adjust_samplingInterval(minimumSamplingInterval: number): number {
     return minimumSamplingInterval;
 }
 
-function is_Variant(v: unknown): boolean {
-    return v instanceof Variant;
-}
-
 function is_StatusCode(v: unknown): boolean {
     return !!(
         v?.constructor &&
@@ -149,11 +145,8 @@ function is_StatusCode(v: unknown): boolean {
     );
 }
 
-function is_Variant_or_StatusCode(v: unknown): boolean {
-    if (is_Variant(v)) {
-        // /@@assert(v.isValid());
-    }
-    return is_Variant(v) || is_StatusCode(v);
+function isThenable<T>(v: T | PromiseLike<T>): v is PromiseLike<T> {
+    return typeof (v as PromiseLike<T> | null | undefined)?.then === "function";
 }
 
 function default_func(this: UAVariable, dataValue1: DataValue, callback1: CallbackT<StatusCode>) {
@@ -213,46 +206,60 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
     implements UAVariable<T>, UAVariableImplExtArray
 {
     // -------------- UAvaraibleImplExArray
-    $$variableType?: UAVariableType;
-    $$dataType?: UADataType = undefined;
-    $$getElementBrowseName?: (extObject: ExtensionObject, index: number | number[]) => QualifiedName;
-    $$extensionObjectArray?: ExtensionObject[];
-    $$indexPropertyName?: string;
+    declare $$variableType?: UAVariableType;
+    declare $$dataType?: UADataType;
+    declare $$getElementBrowseName?: (extObject: ExtensionObject, index: number | number[]) => QualifiedName;
+    declare $$extensionObjectArray?: ExtensionObject[];
+    declare $$indexPropertyName?: string;
     // --------------
 
     public readonly nodeClass = NodeClass.Variable;
 
     public dataType: NodeId;
-    private _basicDataType?: DataType;
+    declare private _basicDataType?: DataType;
 
     // narrowing this to ExtensionObject breaks declaration-merging in ua_two_state_variable.ts and elsewhere
     // (concrete *T variants bind $extensionObject to a different, more specific shape) — see the matching
     // comment on UAVariable.$extensionObject in node-opcua-address-space-base for the documented precedent.
     // biome-ignore lint/suspicious/noExplicitAny: see comment above
-    public $extensionObject?: any;
-    public $set_ExtensionObject?: (newValue: ExtensionObject, sourceTimestamp: PreciseClock, cache: Set<UAVariableImpl>) => void;
+    declare public $extensionObject?: any;
+    declare public $set_ExtensionObject?: (
+        newValue: ExtensionObject,
+        sourceTimestamp: PreciseClock,
+        cache: Set<UAVariableImpl>
+    ) => void;
 
-    public $historicalDataConfiguration?: UAHistoricalDataConfiguration;
-    public varHistorian?: IVariableHistorian;
+    declare public $historicalDataConfiguration?: UAHistoricalDataConfiguration;
+    declare public varHistorian?: IVariableHistorian;
 
     /**
      * @internal @private
      */
     public $dataValue: DataValue;
     public accessLevel: number;
-    public userAccessLevel?: number;
+    declare public userAccessLevel?: number;
     public valueRank: number;
     public minimumSamplingInterval: number;
     public historizing: boolean;
     public semantic_version: number;
     public arrayDimensions: null | number[];
 
-    public _timestamped_get_func?: TimestampGetFunc | null;
-    public _timestamped_set_func?: VariableDataValueSetterWithCallback | null;
-    public _get_func?: GetFunc | null;
-    public _set_func?: ((value: Variant, callback: (err: Error | null, statusCode?: StatusCode) => void) => void) | null;
-    public refreshFunc?: (callback: CallbackT<DataValue>) => void;
-    public __waiting_callbacks?: CallbackT<DataValue>[];
+    declare public _timestamped_get_func?: TimestampGetFunc | null;
+    declare public _timestamped_set_func?: VariableDataValueSetterWithCallback | null;
+    declare public _get_func?: GetFunc | null;
+    declare public _set_func?: ((value: Variant, callback: (err: Error | null, statusCode?: StatusCode) => void) => void) | null;
+    declare public refreshFunc?: (callback: CallbackT<DataValue>) => void;
+    /**
+     * true when refreshFunc only wraps the synchronous getter of a Variable bound with a plain
+     * `get`. readValue evaluates that getter itself: refreshing such a Variable before reading
+     * it, as the Read service does for the others, evaluates the getter twice for nothing.
+     */
+    declare public _refreshFuncWrapsGetter?: boolean;
+    declare public __waiting_callbacks?: CallbackT<DataValue>[];
+    // the variant types already found to fit the DataType below (bit k: DataType k), set on the first write
+    declare private _validatedForDataType?: NodeId;
+    declare private _validatedVariantTypes?: number;
+    declare private __satisfy_waiting_callbacks?: (err: Error | null, dataValue?: DataValue) => void;
 
     get typeDefinitionObj(): UAVariableType {
         /* c8 ignore next */
@@ -318,7 +325,6 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
     }
     private checkPermissionPrivate(context: ISessionContext, permission: PermissionType): boolean {
         if (!context) return true;
-        assert(context instanceof SessionContext);
         if (context.checkPermission) {
             if (!(context.checkPermission instanceof Function)) {
                 errorLog("context checkPermission is not a function");
@@ -437,7 +443,14 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
         if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
             return makeNowDataValue({ statusCode: StatusCodes.BadUserAccessDenied });
         }
-        if (!this.isUserReadable(context)) {
+        // isUserReadable() would evaluate isReadable() and the Read permission a second time, and the
+        // permission lookup walks the namespace metadata. Both just passed above, so only the access
+        // level is left, unless a node replaced isUserReadable (see makeNotReadableIfEnabledFlagIsFalse).
+        const userReadable =
+            this.isUserReadable === UAVariableImpl.prototype.isUserReadable
+                ? this.checkAccessLevelPrivate(context, AccessLevelFlag.CurrentRead)
+                : this.isUserReadable(context);
+        if (!userReadable) {
             return makeNowDataValue({ statusCode: StatusCodes.BadNotReadable });
         }
         if (!isValidDataEncoding(dataEncoding)) {
@@ -1273,6 +1286,7 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             this._get_func = null;
             this._set_func = null;
             this.refreshFunc = undefined;
+            this._refreshFuncWrapsGetter = false;
             this._historyRead = UAVariableImpl.prototype._historyRead;
         }
 
@@ -1303,12 +1317,22 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
     public readValueAsync(context: ISessionContext | null, callback: CallbackT<DataValue>): void;
     public readValueAsync(context: ISessionContext | null): Promise<DataValue>;
     public readValueAsync(context: ISessionContext | null, callback?: CallbackT<DataValue>): Promise<DataValue> | undefined {
-        assert(typeof callback === "function");
+        // written out rather than wrapped with thenify-ex: every sample of a monitored item comes
+        // through here with a callback, and the generic wrapper forwarded it with apply(arguments)
+        if (callback) {
+            this._readValueAsync(context, callback);
+            return undefined;
+        }
+        return new Promise<DataValue>((resolve, reject) => {
+            this._readValueAsync(context, (err, dataValue) => (err ? reject(err) : resolve(dataValue as DataValue)));
+        });
+    }
 
+    private _readValueAsync(context: ISessionContext | null, callback: CallbackT<DataValue>): void {
         context = context || SessionContext.defaultContext;
 
         this.__waiting_callbacks = this.__waiting_callbacks || [];
-        this.__waiting_callbacks.push(callback as CallbackT<DataValue>);
+        this.__waiting_callbacks.push(callback);
 
         const _readValueAsync_in_progress = this.__waiting_callbacks.length >= 2;
         if (_readValueAsync_in_progress) {
@@ -1320,19 +1344,10 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             return;
         }
 
-        const readImmediate = (innerCallback: (err: Error | null, dataValue: DataValue) => void) => {
-            assert(this.$dataValue instanceof DataValue);
-            const dataValue = this.readValue(context);
-            innerCallback(null, dataValue);
-        };
-
-        let func: (innerCallback: (err: Error | null, dataValue: DataValue) => void) => void;
-
-        // stamped like the same gates of readValue(): the requested timestamps are expected
-        // on a Bad result too (FEAT-34)
-        const answerStatusOnly = (statusCode: StatusCode) => (innerCallback: (err: Error | null, dataValue: DataValue) => void) =>
-            innerCallback(null, makeNowDataValue({ statusCode }));
-
+        // runs once per sample of every monitored item, so nothing here allocates a closure or
+        // binds a function: the denial (if any) is a StatusCode, and the callback that releases
+        // the waiting readers is made once per variable
+        let denied: StatusCode | null = null;
         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
@@ -1340,30 +1355,48 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             // through readValue(). Without this check here, a node hardened
             // with AccessRestrictions(EncryptionRequired) answered its value
             // over an unencrypted channel.
-            func = answerStatusOnly(StatusCodes.BadSecurityModeInsufficient);
+            denied = StatusCodes.BadSecurityModeInsufficient;
         } else if (!this.isReadable(context)) {
-            func = answerStatusOnly(StatusCodes.BadNotReadable);
+            denied = StatusCodes.BadNotReadable;
         } else if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
-            func = answerStatusOnly(StatusCodes.BadUserAccessDenied);
-        } else if (!this.isUserReadable(context)) {
-            func = answerStatusOnly(StatusCodes.BadNotReadable);
-        } else {
-            const clock = getCurrentClock();
-            func = typeof this.refreshFunc === "function" ? this.asyncRefresh.bind(this, clock) : readImmediate;
+            denied = StatusCodes.BadUserAccessDenied;
+        } else if (
+            // as in readValue(): the Read permission has just passed, only the access level is
+            // left, unless a node replaced isUserReadable (see makeNotReadableIfEnabledFlagIsFalse)
+            this.isUserReadable === UAVariableImpl.prototype.isUserReadable
+                ? !this.checkAccessLevelPrivate(context, AccessLevelFlag.CurrentRead)
+                : !this.isUserReadable(context)
+        ) {
+            denied = StatusCodes.BadNotReadable;
         }
 
-        const satisfy_callbacks = (err: Error | null, dataValue?: DataValue) => {
+        this.__satisfy_waiting_callbacks ??= (err: Error | null, dataValue?: DataValue) => {
             // now call all pending callbacks
             const callbacks = this.__waiting_callbacks || [];
             this.__waiting_callbacks = [];
-            const _n = callbacks.length;
             for (const callback1 of callbacks) {
                 callback1.call(this, err, dataValue);
             }
         };
+        const satisfy_callbacks = this.__satisfy_waiting_callbacks;
 
         try {
-            func.call(this, satisfy_callbacks);
+            if (denied) {
+                // stamped like the same gates of readValue(): the requested timestamps are expected
+                // on a Bad result too (FEAT-34)
+                satisfy_callbacks(null, makeNowDataValue({ statusCode: denied }));
+            } else if (typeof this.refreshFunc === "function") {
+                const clock = getCurrentClock();
+                if (this.asyncRefresh === wrappedAsyncRefresh) {
+                    // the thenified wrapper adds nothing when a callback is given
+                    asyncRefreshImpl.call(this, clock, satisfy_callbacks);
+                } else {
+                    this.asyncRefresh(clock, satisfy_callbacks);
+                }
+            } else {
+                assert(this.$dataValue instanceof DataValue);
+                satisfy_callbacks(null, this.readValue(context));
+            }
         } catch (err) {
             // c8 ignore next
             if (doDebug) {
@@ -1374,7 +1407,6 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             }
             satisfy_callbacks(err as Error);
         }
-        return undefined;
     }
 
     public getWriteMask(): number {
@@ -1879,7 +1911,27 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
     }
 
     public _validate_DataType(variantDataType: DataType): boolean {
-        return validateDataTypeCorrectness(this.addressSpace, this.dataType, variantDataType, /* allow Nulls */ false, this.nodeId);
+        // every write of a Variable checks the same variant type against the same DataType: a check that
+        // passed is remembered while the DataType stays the same; a refusal is always checked again
+        const bit = variantDataType >= 0 && variantDataType < 31 ? 1 << variantDataType : 0;
+        if (bit && this._validatedForDataType === this.dataType && ((this._validatedVariantTypes ?? 0) & bit) !== 0) {
+            return true;
+        }
+        const valid = validateDataTypeCorrectness(
+            this.addressSpace,
+            this.dataType,
+            variantDataType,
+            /* allow Nulls */ false,
+            this.nodeId
+        );
+        if (valid && bit) {
+            if (this._validatedForDataType !== this.dataType) {
+                this._validatedForDataType = this.dataType;
+                this._validatedVariantTypes = 0;
+            }
+            this._validatedVariantTypes = (this._validatedVariantTypes ?? 0) | bit;
+        }
+        return valid;
     }
 
     public _internal_set_value(value: Variant): void {
@@ -1936,9 +1988,19 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
      */
     public _inner_replace_dataValue(dataValue: DataValue, indexRange?: NumericRange | null) {
         assert(this.$dataValue.value instanceof Variant);
-        const old_dataValue = this.$dataValue.clone();
 
-        if (this.$$extensionObjectArray && dataValue.value.arrayType !== VariantArrayType.Scalar) {
+        const replacesArrayInPlace = !!this.$$extensionObjectArray && dataValue.value.arrayType !== VariantArrayType.Scalar;
+        const replacesExtensionObjectInPlace =
+            this._basicDataType === DataType.ExtensionObject &&
+            this.valueRank === -1 &&
+            !!this.$set_ExtensionObject &&
+            dataValue.value.arrayType === VariantArrayType.Scalar;
+        // the previous value is needed intact for the comparison below. Only the two branches that
+        // write into $dataValue in place need a copy of it: the common case swaps in the new object
+        // and leaves the old one untouched
+        const old_dataValue = replacesArrayInPlace || replacesExtensionObjectInPlace ? this.$dataValue.clone() : this.$dataValue;
+
+        if (replacesArrayInPlace) {
             // we have a bounded array or matrix
             assert(Array.isArray(dataValue.value.value));
             if (this.$$extensionObjectArray !== this.$dataValue.value.value) {
@@ -1952,12 +2014,7 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             this.$dataValue.serverPicoseconds = dataValue.serverPicoseconds;
             this.$dataValue.sourceTimestamp = dataValue.sourceTimestamp;
             this.$dataValue.sourcePicoseconds = dataValue.sourcePicoseconds;
-        } else if (
-            this._basicDataType === DataType.ExtensionObject &&
-            this.valueRank === -1 &&
-            this.$set_ExtensionObject &&
-            dataValue.value.arrayType === VariantArrayType.Scalar
-        ) {
+        } else if (replacesExtensionObjectInPlace && this.$set_ExtensionObject) {
             // the entire extension object is changed.
             this.$dataValue.statusCode = this.$dataValue.statusCode || StatusCodes.Good;
             const preciseClock = coerceClock(this.$dataValue.sourceTimestamp, this.$dataValue.sourcePicoseconds);
@@ -1966,14 +2023,16 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             this.$dataValue = dataValue;
             this.$dataValue.statusCode = this.$dataValue.statusCode || StatusCodes.Good;
         }
-        // repair missing timestamps
-        const now = new Date();
+        // repair missing timestamps (the clock is only read when one is missing: this runs on
+        // every stored value, and most arrive with both timestamps)
+        let now: Date | undefined;
         if (!dataValue.serverTimestamp) {
+            now = new Date();
             this.$dataValue.serverTimestamp = old_dataValue.serverTimestamp || now;
             this.$dataValue.serverPicoseconds = old_dataValue.serverPicoseconds || 0;
         }
         if (!dataValue.sourceTimestamp) {
-            this.$dataValue.sourceTimestamp = old_dataValue.sourceTimestamp || now;
+            this.$dataValue.sourceTimestamp = old_dataValue.sourceTimestamp || (now ?? new Date());
             this.$dataValue.sourcePicoseconds = old_dataValue.sourcePicoseconds || 0;
         }
 
@@ -1997,7 +2056,7 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
                     this.touchValue(preciseClock);
                     propagateTouchValueDownward(this, preciseClock, cache);
                 }
-            } else {
+            } else if ((this as UAVariable).listenerCount("value_changed") > 0) {
                 (this as UAVariable).emit("value_changed", this.$dataValue.clone(), indexRange);
             }
         }
@@ -2105,11 +2164,15 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
 import type { IStructuredTypeSchema } from "node-opcua-factory";
 import { withCallback } from "thenify-ex";
 
-UAVariableImpl.prototype.asyncRefresh = withCallback(UAVariableImpl.prototype.asyncRefresh);
+// readValueAsync calls the unwrapped asyncRefresh directly: binding the thenified wrapper on
+// every sample cost more than the refresh itself
+const asyncRefreshImpl: (this: UAVariableImpl, oldestDate: PreciseClock, callback: CallbackT<DataValue>) => void =
+    UAVariableImpl.prototype.asyncRefresh;
+UAVariableImpl.prototype.asyncRefresh = withCallback(asyncRefreshImpl);
+const wrappedAsyncRefresh = 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);
 
 export interface UAVariableImplExtArray {
     $$variableType?: UAVariableType;
@@ -2230,26 +2293,24 @@ type f3<T, D, R> = (this: T, data: D, callback: (err: Error | null, r?: R) => vo
 function turn_sync_to_async<T, D, R>(f: f1<T, D, R> | f2<T, D, R> | f3<T, D, R>, numberOfArgs: number): f3<T, D, R> {
     if (f.length <= numberOfArgs) {
         return function (this: T, data: D, callback: (err: Error | null, r?: R) => void) {
-            new Promise<R>((resolve, reject) => {
-                try {
-                    // const ff1 = f as f1<T, D, R>;
-                    const ff2 = f as f2<T, D, R>;
-                    const r: R | Promise<R> = ff2.call(this, data);
-                    if (r instanceof Promise) {
-                        r.then(resolve, reject);
-                    } else {
-                        resolve(r);
-                    }
-                } catch (err) {
-                    reject(err);
-                }
-            })
-                .then((r) => {
-                    callback(null, r);
-                })
-                .catch((err) => {
-                    callback(err as Error);
-                });
+            const ff2 = f as f2<T, D, R>;
+            let r: R | Promise<R>;
+            try {
+                r = ff2.call(this, data);
+            } catch (err) {
+                callback(err as Error);
+                return;
+            }
+            if (r instanceof Promise) {
+                r.then(
+                    (value) => callback(null, value),
+                    (err) => callback(err as Error)
+                );
+                return;
+            }
+            // a synchronous function answers at once: a Write of such Variables completes without waiting
+            // a turn per value, under one permission cache for the whole request
+            callback(null, r);
         };
     } else {
         assert(f.length === numberOfArgs + 1);
@@ -2307,12 +2368,26 @@ function _Variable_bind_with_timestamped_get(
     assert(!this._timestamped_get_func);
 
     const async_refresh_func = (callback: (err: Error | null, dataValue?: DataValue) => void) => {
-        Promise.resolve((this._timestamped_get_func as VariableDataValueGetterSync).call(this))
-            .then((dataValue) => callback(null, dataValue))
-            .catch((err) => {
-                errorLog("asyncRefresh error: Variable is  ", this.nodeId.toString(), this.browseName.toString());
-                callback(err as Error);
-            });
+        const reportError = (err: unknown) => {
+            errorLog("asyncRefresh error: Variable is  ", this.nodeId.toString(), this.browseName.toString());
+            callback(err as Error);
+        };
+        // a getter that throws is reported by asyncRefresh, which calls this function
+        const dataValueOrPromise = (this._timestamped_get_func as () => DataValue | Promise<DataValue>).call(this);
+        if (isThenable(dataValueOrPromise)) {
+            Promise.resolve(dataValueOrPromise)
+                .then((dataValue) => callback(null, dataValue))
+                .catch(reportError);
+            return;
+        }
+        // the getter is synchronous (it always is for a Variable bound with a plain `get`):
+        // answer at once. A promise here costs every Read of the Variable an allocation and
+        // a turn of the microtask queue, for a value that is already known.
+        try {
+            callback(null, dataValueOrPromise);
+        } catch (err) {
+            reportError(err);
+        }
     };
     const pThis = this as UAVariable;
     if (options.timestamped_get.length === 0) {
@@ -2356,21 +2431,10 @@ function _Variable_bind_with_simple_get(this: UAVariableImpl, options: GetterOpt
     const timestamped_get_func_from__Variable_bind_with_simple_get = () => {
         const value: Variant | StatusCode = (this._get_func as GetFunc)();
 
-        /* c8 ignore next */
-        if (!is_Variant_or_StatusCode(value)) {
-            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 DataValue({ statusCode: value as StatusCode });
-        } else {
-            if (!this.$dataValue?.statusCode.isGoodish() || !sameVariant(this.$dataValue.value, value as Variant)) {
+        // a getter returns a Variant on every read but a failing one: test for it first, as
+        // is_StatusCode ends in comparisons of constructor names
+        if (value instanceof Variant) {
+            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 } = getCurrentClock();
@@ -2382,12 +2446,26 @@ function _Variable_bind_with_simple_get(this: UAVariableImpl, options: GetterOpt
             }
             return this.$dataValue;
         }
+
+        /* c8 ignore next */
+        if (!is_StatusCode(value)) {
+            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 !!!"
+            );
+        }
+        return new DataValue({ statusCode: value as StatusCode });
     };
 
     _Variable_bind_with_timestamped_get.call(this, {
         get: undefined,
         timestamped_get: timestamped_get_func_from__Variable_bind_with_simple_get
     });
+    this._refreshFuncWrapsGetter = true;
 }
 
 type SimpleSetOptions = { set?: SetFunc; timestamped_set: undefined };
@@ -2440,8 +2518,18 @@ function _Variable_bind_with_timestamped_set(
         "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<StatusCode, DataValue, UAVariable>(options.timestamped_set);
+    // the callback form of a setter is a stateless wrapper around it (it takes the variable as
+    // `this`): one per setter function, not one per variable. Every writable variable without a
+    // setter of its own binds the same default, and a closure per variable was 110 bytes each
+    let setter = callbackSetters.get(options.timestamped_set);
+    if (!setter) {
+        setter = convertToCallbackFunction1<StatusCode, DataValue, UAVariable>(options.timestamped_set);
+        callbackSetters.set(options.timestamped_set, setter);
+    }
+    this._timestamped_set_func = setter;
 }
+/** the callback form of each setter function met so far, see _Variable_bind_with_timestamped_set */
+const callbackSetters = new WeakMap<TimestampSetFunc, VariableDataValueSetterWithCallback>();
 
 interface SetterOptions {
     set?: SetFunc;
@@ -2528,9 +2616,9 @@ export class UAVariableImplT<T, DT extends DataType> extends UAVariableImpl impl
         context: ISessionContext | null,
         callback?: CallbackT<DataValueT<T, DT>>
     ): Promise<DataValueT<T, DT>> | undefined {
-        // forward the arguments we were actually given. The base method is thenified, and
-        // thenify decides between promise and callback form by argument count, so passing an
-        // explicit undefined callback makes it hand that undefined straight through.
+        // forward the arguments we were actually given: the base method picks the promise or the
+        // callback form from the callback it receives (writeValue below, still thenified, picks
+        // it from the argument count, where an explicit undefined callback would be passed on)
         if (callback === undefined) {
             return super.readValueAsync(context) as Promise<DataValueT<T, DT>>;
         }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "node-opcua-address-space",
     "type": "module",
-    "version": "2.186.17",
+    "version": "2.187.1",
     "description": "pure nodejs OPCUA SDK - module address-space",
     "main": "./dist/api/index.js",
     "types": "./dist/api/index.d.ts",
@@ -23,48 +23,49 @@
         "@types/semver": "7.8.0",
         "chalk": "6.0.1",
         "dequeue": "^1.0.5",
-        "node-opcua-address-space-base": "2.186.17",
+        "node-opcua-address-space-base": "2.187.0",
+        "node-opcua-address-space-store": "2.187.1",
         "node-opcua-assert": "2.186.7",
-        "node-opcua-basic-types": "2.186.7",
-        "node-opcua-binary-stream": "2.186.7",
-        "node-opcua-client-dynamic-extension-object": "2.186.17",
+        "node-opcua-basic-types": "2.187.0",
+        "node-opcua-binary-stream": "2.187.0",
+        "node-opcua-client-dynamic-extension-object": "2.187.0",
         "node-opcua-constants": "2.185.0",
-        "node-opcua-crypto": "6.1.4",
-        "node-opcua-data-access": "2.186.10",
-        "node-opcua-data-model": "2.186.10",
-        "node-opcua-data-value": "2.186.10",
-        "node-opcua-date-time": "2.186.7",
+        "node-opcua-crypto": "6.2.0",
+        "node-opcua-data-access": "2.187.0",
+        "node-opcua-data-model": "2.187.0",
+        "node-opcua-data-value": "2.187.0",
+        "node-opcua-date-time": "2.187.0",
         "node-opcua-debug": "2.186.7",
-        "node-opcua-enum": "2.186.7",
-        "node-opcua-extension-object": "2.186.7",
-        "node-opcua-factory": "2.186.7",
-        "node-opcua-nodeid": "2.186.7",
-        "node-opcua-nodeset-ua": "2.186.17",
-        "node-opcua-numeric-range": "2.186.7",
+        "node-opcua-enum": "2.187.0",
+        "node-opcua-extension-object": "2.187.0",
+        "node-opcua-factory": "2.187.0",
+        "node-opcua-nodeid": "2.187.0",
+        "node-opcua-nodeset-ua": "2.187.0",
+        "node-opcua-numeric-range": "2.187.0",
         "node-opcua-object-registry": "2.186.7",
-        "node-opcua-pseudo-session": "2.186.17",
-        "node-opcua-service-browse": "2.186.10",
-        "node-opcua-service-call": "2.186.10",
-        "node-opcua-service-history": "2.186.10",
-        "node-opcua-service-translate-browse-path": "2.186.16",
-        "node-opcua-service-write": "2.186.10",
-        "node-opcua-status-code": "2.186.7",
-        "node-opcua-types": "2.186.10",
-        "node-opcua-utils": "2.186.7",
-        "node-opcua-variant": "2.186.10",
-        "node-opcua-xml2json": "2.186.7",
+        "node-opcua-pseudo-session": "2.187.0",
+        "node-opcua-service-browse": "2.187.0",
+        "node-opcua-service-call": "2.187.0",
+        "node-opcua-service-history": "2.187.0",
+        "node-opcua-service-translate-browse-path": "2.187.0",
+        "node-opcua-service-write": "2.187.0",
+        "node-opcua-status-code": "2.187.0",
+        "node-opcua-types": "2.187.0",
+        "node-opcua-utils": "2.187.0",
+        "node-opcua-variant": "2.187.0",
+        "node-opcua-xml2json": "2.187.0",
         "semver": "^7.8.5",
         "thenify-ex": "4.4.0",
         "xml-writer": "^1.7.0"
     },
     "devDependencies": {
         "humanize": "0.0.9",
-        "node-opcua-benchmarker": "2.186.7",
+        "node-opcua-benchmarker": "2.187.0",
         "node-opcua-leak-detector": "2.186.7",
-        "node-opcua-nodesets": "2.185.0",
-        "node-opcua-packet-analyzer": "2.186.7",
-        "node-opcua-schemas": "2.186.10",
-        "node-opcua-service-filter": "2.186.17",
+        "node-opcua-nodesets": "2.187.0",
+        "node-opcua-packet-analyzer": "2.187.0",
+        "node-opcua-schemas": "2.187.0",
+        "node-opcua-service-filter": "2.187.0",
         "node-opcua-test-fixtures": "2.184.0",
         "node-opcua-test-helpers": "2.184.0"
     },
@@ -83,7 +84,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "bdb3848c06d19056a99dfc06ef73771a0666472f",
+    "gitHead": "706db482c6f77cd5c7c1f98f9f7cf1c5841a0161",
     "files": [
         "dist",
         "distHelpers",