node-opcua-address-space 2.186.17 → 2.187.0

package/impl/reference_impl.ts

@@ -157,7 +157,8 @@ export class ReferenceImpl implements UAReference {
 
     // cache
     private __hash?: string;
-    private __key?: ReferenceKey;
+    /** the key this reference is indexed under, computed once by key(); read by ReferenceIndex */
+    public _key?: ReferenceKey;
 
     constructor(options: AddReferenceOpts | UAReference) {
         assert(options.referenceType instanceof NodeId);
@@ -209,10 +210,10 @@ export class ReferenceImpl implements UAReference {
      * the key this reference is indexed under in the node holding it, computed once
      */
     key(ordinals: ReferenceTypeOrdinals): ReferenceKey {
-        if (this.__key === undefined) {
-            this.__key = referenceKey(this.isForward, ordinals.referenceTypeOrdinal(this.referenceType), nodeIdKey(this.nodeId));
+        if (this._key === undefined) {
+            this._key = referenceKey(this.isForward, ordinals.referenceTypeOrdinal(this.referenceType), nodeIdKey(this.nodeId));
         }
-        return this.__key;
+        return this._key;
     }
 
     /**
@@ -230,7 +231,7 @@ export class ReferenceImpl implements UAReference {
      */
     public dispose(): void {
         this.__hash = undefined;
-        this.__key = undefined;
+        // _key stays: the index holding this reference finds it by that key (ReferenceIndex)
         this.node = undefined;
         /*
         this._referenceType = null;

package/impl/reference_index.ts

@@ -0,0 +1,116 @@
+import type { UAReference } from "node-opcua-address-space-base";
+import type { ReferenceImpl, ReferenceKey } from "./reference_impl.js";
+
+/**
+ * above this many references a node indexes them in a Map; below, a plain array scanned on
+ * lookup. A leaf node holds two or three references, and a Map with its hash table costs
+ * about 280 bytes even when nearly empty: a quarter of what a node weighs. On a model of a
+ * million nodes that is the difference between fitting in memory and not.
+ */
+const MAP_THRESHOLD = 16;
+
+/**
+ * The references a node holds, by key (see ReferenceImpl#key). It offers what the code uses of
+ * a Map: get, has, set, delete, values, size and iteration.
+ *
+ * The key is not stored twice: a reference caches its own key when it is indexed, and a scan
+ * compares that cached key.
+ */
+export class ReferenceIndex {
+    #refs: UAReference[] | null = null;
+    #map: Map<ReferenceKey, UAReference> | null = null;
+
+    public get size(): number {
+        return this.#map ? this.#map.size : this.#refs ? this.#refs.length : 0;
+    }
+
+    #indexOf(key: ReferenceKey): number {
+        const refs = this.#refs as ReferenceImpl[];
+        for (let i = 0; i < refs.length; i++) {
+            if (refs[i]._key === key) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public has(key: ReferenceKey): boolean {
+        if (this.#map) {
+            return this.#map.has(key);
+        }
+        return this.#refs !== null && this.#indexOf(key) !== -1;
+    }
+
+    public get(key: ReferenceKey): UAReference | undefined {
+        if (this.#map) {
+            return this.#map.get(key);
+        }
+        if (this.#refs === null) {
+            return undefined;
+        }
+        const index = this.#indexOf(key);
+        return index === -1 ? undefined : this.#refs[index];
+    }
+
+    /** `key` must be the reference's own key (ReferenceImpl#key), which is what callers index by */
+    public set(key: ReferenceKey, reference: UAReference): this {
+        if (this.#map) {
+            this.#map.set(key, reference);
+            return this;
+        }
+        if (this.#refs === null) {
+            this.#refs = [reference];
+            return this;
+        }
+        const index = this.#indexOf(key);
+        if (index !== -1) {
+            this.#refs[index] = reference; // check-proto-pollution: ok - numeric index
+            return this;
+        }
+        if (this.#refs.length >= MAP_THRESHOLD) {
+            const map = new Map<ReferenceKey, UAReference>();
+            for (const ref of this.#refs) {
+                map.set((ref as ReferenceImpl)._key as ReferenceKey, ref);
+            }
+            map.set(key, reference);
+            this.#map = map;
+            this.#refs = null;
+            return this;
+        }
+        // concat allocates exactly the length needed; push would grow the backing store to 17
+        // slots, which is more than the Map this replaces
+        this.#refs = this.#refs.concat(reference);
+        return this;
+    }
+
+    public delete(key: ReferenceKey): boolean {
+        if (this.#map) {
+            return this.#map.delete(key);
+        }
+        if (this.#refs === null) {
+            return false;
+        }
+        const index = this.#indexOf(key);
+        if (index === -1) {
+            return false;
+        }
+        this.#refs = this.#refs.length === 1 ? null : this.#refs.filter((_r, i) => i !== index);
+        return true;
+    }
+
+    public clear(): void {
+        this.#refs = null;
+        this.#map = null;
+    }
+
+    public values(): IterableIterator<UAReference> {
+        if (this.#map) {
+            return this.#map.values();
+        }
+        return (this.#refs ?? []).values();
+    }
+
+    public [Symbol.iterator](): IterableIterator<UAReference> {
+        return this.values();
+    }
+}

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,57 @@ 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>[];
+    declare private __satisfy_waiting_callbacks?: (err: Error | null, dataValue?: DataValue) => void;
 
     get typeDefinitionObj(): UAVariableType {
         /* c8 ignore next */
@@ -318,7 +322,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 +440,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 +1283,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 +1314,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 +1341,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 +1352,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 +1404,6 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             }
             satisfy_callbacks(err as Error);
         }
-        return undefined;
     }
 
     public getWriteMask(): number {
@@ -1936,9 +1965,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 +1991,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 +2000,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 +2033,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 +2141,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;
@@ -2307,12 +2347,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 +2410,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 +2425,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 +2497,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 +2595,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>>;
         }