node-opcua-address-space 2.187.12 → 2.187.17

package/impl/address_space.ts

@@ -942,7 +942,7 @@ export class AddressSpaceImpl implements AddressSpacePrivate {
      *
      *
      */
-    public browsePath(browsePath: BrowsePath): BrowsePathResult {
+    public browsePath(browsePath: BrowsePath, context?: ISessionContext): BrowsePathResult {
         assert(browsePath instanceof BrowsePath);
 
         const startingNode = this.findNode(browsePath.startingNode);
@@ -989,10 +989,21 @@ export class AddressSpaceImpl implements AddressSpacePrivate {
 
         const res: BrowsePathTargetOptions[] = [];
 
+        // a node the context cannot browse is invisible: neither followed nor returned
+        const isBrowseDenied = (nodeId: NodeId): boolean => {
+            if (!context) {
+                return false;
+            }
+            const node = this.findNode(nodeId);
+            return !!node && context.isBrowseAccessRestricted(node);
+        };
+
         const explore_element = (curNodeObject: BaseNode, elements: RelativePathElement[], index: number) => {
             const element = elements[index];
             const is_last = index + 1 === elements.length;
-            const nodeIds = curNodeObject.browseNodeByTargetName(element, is_last);
+            const nodeIds = curNodeObject
+                .browseNodeByTargetName(element, is_last)
+                .filter((nodeId: NodeId) => !isBrowseDenied(nodeId));
             const targets = nodeIds.map((nodeId: NodeId) => {
                 return {
                     remainingPathIndex: elements.length - index,

package/impl/nodeset_tools/construct_namespace_dependency.ts

@@ -239,6 +239,11 @@ export function _getCompleteRequiredModelsFromValuesAndReferences(
         } else if (node.nodeClass === NodeClass.VariableType) {
             exploreValue((node as UAVariableTypeImpl).value);
         }
+        // the exporter translates the RoleId of every RolePermission too: a role of a model the
+        // namespace uses nothing else from is a dependency all the same
+        for (const rolePermission of (<BaseNodeImpl>node).rolePermissions || []) {
+            consider(rolePermission.roleId.namespace);
+        }
         const references = (<BaseNodeImpl>node).allReferences();
         for (const reference of references) {
             // check referenceId

package/impl/ua_variable_impl.ts

@@ -27,7 +27,9 @@ import {
     makeDefaultCloneExtraInfo,
     type SetFunc,
     type VariableDataValueGetterSync,
+    type VariableDataValueGetterWithContext,
     type VariableDataValueSetterWithCallback,
+    type VariableDataValueSetterWithContext,
     type VariableSetter
 } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
@@ -248,13 +250,18 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
     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;
+    declare public refreshFunc?: (callback: CallbackT<DataValue>, context?: ISessionContext) => 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;
+    /**
+     * true when the timestamped getter answered a Promise when it was bound: it is run by asyncRefresh
+     * only. readValue cannot use a Promise: it serves the value the last refresh left.
+     */
+    declare public _getterIsAsync?: boolean;
     // the read that started the refresh in progress, and the reads that came while it was (an array only then):
     // a sampled variable is read once per sample, and one at a time
     declare private __waiting_callback?: CallbackT<DataValue>;
@@ -463,7 +470,7 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             return makeNowDataValue({ statusCode: StatusCodes.BadDataEncodingInvalid });
         }
 
-        if (this._timestamped_get_func) {
+        if (this._timestamped_get_func && !this._getterIsAsync) {
             if (this._timestamped_get_func.length === 0) {
                 const dataValueOrPromise = (this._timestamped_get_func as VariableDataValueGetterSync)();
                 if (!Object.hasOwn(dataValueOrPromise.constructor.prototype, "then")) {
@@ -547,9 +554,13 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
         return dataTypeNode._getEnumerationInfo();
     }
 
-    public asyncRefresh(oldestDate: PreciseClock, callback: CallbackT<DataValue>): void;
+    public asyncRefresh(oldestDate: PreciseClock, callback: CallbackT<DataValue>, context?: ISessionContext): void;
     public asyncRefresh(oldestDate: PreciseClock): Promise<DataValue>;
-    public asyncRefresh(oldestDate: PreciseClock, callback?: CallbackT<DataValue>): Promise<DataValue> | undefined {
+    public asyncRefresh(
+        oldestDate: PreciseClock,
+        callback?: CallbackT<DataValue>,
+        context?: ISessionContext
+    ): Promise<DataValue> | undefined {
         // asyncRefresh is always invoked with a callback at runtime: the public overload without
         // a callback is only reachable through the withCallback() wrapper installed below, which
         // synthesizes one before calling into this implementation.
@@ -588,33 +599,37 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
         const requestedAtPicoseconds = oldestDate.picoseconds;
         let answeredAtOnce = true;
         try {
-            this.refreshFunc.call(this, (err: Error | null, dataValue?: DataValueLike) => {
-                // c8 ignore next
-                if (err || !dataValue) {
-                    errorLog(
-                        "-------------- refresh call failed",
-                        this.browseName.toString(),
-                        this.nodeId.toString(),
-                        err?.message
-                    );
-                    dataValue = { statusCode: StatusCodes.BadNoDataAvailable };
-                }
-                if (dataValue && dataValue !== this.$dataValue) {
-                    const refreshed = coerceDataValue(dataValue);
-                    if (!refreshed.serverTimestamp) {
-                        if (answeredAtOnce && sharedClock) {
-                            refreshed.serverTimestamp = requestedAt;
-                            refreshed.serverPicoseconds = requestedAtPicoseconds;
-                        } else {
-                            const now = getCurrentClock();
-                            refreshed.serverTimestamp = now.timestamp;
-                            refreshed.serverPicoseconds = now.picoseconds;
+            this.refreshFunc.call(
+                this,
+                (err: Error | null, dataValue?: DataValueLike) => {
+                    // c8 ignore next
+                    if (err || !dataValue) {
+                        errorLog(
+                            "-------------- refresh call failed",
+                            this.browseName.toString(),
+                            this.nodeId.toString(),
+                            err?.message
+                        );
+                        dataValue = { statusCode: StatusCodes.BadNoDataAvailable };
+                    }
+                    if (dataValue && dataValue !== this.$dataValue) {
+                        const refreshed = coerceDataValue(dataValue);
+                        if (!refreshed.serverTimestamp) {
+                            if (answeredAtOnce && sharedClock) {
+                                refreshed.serverTimestamp = requestedAt;
+                                refreshed.serverPicoseconds = requestedAtPicoseconds;
+                            } else {
+                                const now = getCurrentClock();
+                                refreshed.serverTimestamp = now.timestamp;
+                                refreshed.serverPicoseconds = now.picoseconds;
+                            }
                         }
+                        this._internal_set_dataValue(refreshed, null);
                     }
-                    this._internal_set_dataValue(refreshed, null);
-                }
-                cb(err, this.$dataValue);
-            });
+                    cb(err, this.$dataValue);
+                },
+                context
+            );
             answeredAtOnce = false;
         } catch (err) {
             errorLog("-------------- refresh call failed 2", this.browseName.toString(), this.nodeId.toString());
@@ -996,77 +1011,88 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
         }
         assert(write_func);
 
-        write_func.call(this, dataValue, (err?: Error | null, statusCode1?: StatusCode) => {
-            if (!err) {
-                dataValue && this.verifyVariantCompatibility(dataValue.value);
-
-                if (indexRange && !indexRange.isEmpty()) {
-                    if (!indexRange.isValid()) {
-                        callback?.(null, StatusCodes.BadIndexRangeInvalid);
+        write_func.call(
+            this,
+            dataValue,
+            (err?: Error | null, statusCode1?: StatusCode) => {
+                if (!err) {
+                    // a write the setter answers Bad did not happen: the stored value stays as it was
+                    if (statusCode1?.isNotGood()) {
+                        callback?.(null, statusCode1);
                         return;
                     }
+                    dataValue && this.verifyVariantCompatibility(dataValue.value);
 
-                    const newArrayOrMatrix = dataValue.value.value;
-
-                    if (dataValue.value.arrayType === VariantArrayType.Array) {
-                        if (this.$dataValue.value.arrayType !== VariantArrayType.Array) {
-                            callback(null, StatusCodes.BadTypeMismatch);
+                    if (indexRange && !indexRange.isEmpty()) {
+                        if (!indexRange.isValid()) {
+                            callback?.(null, StatusCodes.BadIndexRangeInvalid);
                             return;
                         }
-                        // check that destination data is also an array
-                        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(StatusCodes.Good)) {
-                            callback?.(null, result.statusCode);
-                            return;
-                        }
-                        dataValue.value.value = result.array;
-
-                        // scrap original array so we detect range
-                        this.$dataValue.value.value = null;
-                    } else if (dataValue.value.arrayType === VariantArrayType.Matrix) {
-                        const dimensions = this.$dataValue.value.dimensions;
-                        if (this.$dataValue.value.arrayType !== VariantArrayType.Matrix || !dimensions) {
-                            // not a matrix !
+                        const newArrayOrMatrix = dataValue.value.value;
+
+                        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
+                            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(StatusCodes.Good)) {
+                                callback?.(null, result.statusCode);
+                                return;
+                            }
+                            dataValue.value.value = result.array;
+
+                            // scrap original array so we detect range
+                            this.$dataValue.value.value = null;
+                        } else if (dataValue.value.arrayType === VariantArrayType.Matrix) {
+                            const dimensions = this.$dataValue.value.dimensions;
+                            if (this.$dataValue.value.arrayType !== VariantArrayType.Matrix || !dimensions) {
+                                // not a matrix !
+                                callback?.(null, StatusCodes.BadTypeMismatch);
+                                return;
+                            }
+                            const matrix = this.$dataValue.value.value;
+                            const result = indexRange.set_values_matrix(
+                                {
+                                    matrix,
+                                    dimensions
+                                },
+                                newArrayOrMatrix
+                            );
+                            if (result.statusCode.isNot(StatusCodes.Good)) {
+                                callback?.(null, result.statusCode);
+                                return;
+                            }
+                            dataValue.value.dimensions = this.$dataValue.value.dimensions;
+                            dataValue.value.value = result.matrix;
+
+                            // scrap original array so we detect range
+                            this.$dataValue.value.value = null;
+                        } else {
                             callback?.(null, StatusCodes.BadTypeMismatch);
                             return;
                         }
-                        const matrix = this.$dataValue.value.value;
-                        const result = indexRange.set_values_matrix(
-                            {
-                                matrix,
-                                dimensions
-                            },
-                            newArrayOrMatrix
-                        );
-                        if (result.statusCode.isNot(StatusCodes.Good)) {
-                            callback?.(null, result.statusCode);
-                            return;
+                    }
+                    try {
+                        this._internal_set_dataValue(dataValue, indexRange);
+                    } catch (err) {
+                        if (types.isNativeError(err)) {
+                            warningLog(err.message);
                         }
-                        dataValue.value.dimensions = this.$dataValue.value.dimensions;
-                        dataValue.value.value = result.matrix;
-
-                        // scrap original array so we detect range
-                        this.$dataValue.value.value = null;
-                    } else {
-                        callback?.(null, StatusCodes.BadTypeMismatch);
+                        callback?.(null, StatusCodes.BadInternalError);
                         return;
                     }
                 }
-                try {
-                    this._internal_set_dataValue(dataValue, indexRange);
-                } catch (err) {
-                    if (types.isNativeError(err)) {
-                        warningLog(err.message);
-                    }
-                    callback?.(null, StatusCodes.BadInternalError);
-                    return;
-                }
-            }
-            callback?.(err || null, statusCode1);
-        });
+                callback?.(err || null, statusCode1);
+            },
+            context,
+            indexRange
+        );
         return undefined;
     }
 
@@ -1299,6 +1325,7 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             this._set_func = null;
             this.refreshFunc = undefined;
             this._refreshFuncWrapsGetter = false;
+            this._getterIsAsync = false;
             this._historyRead = UAVariableImpl.prototype._historyRead;
         }
 
@@ -1344,11 +1371,47 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
         });
     }
 
+    /**
+     * why this context may not read the Value, or null when it may: the gates of readValue(),
+     * applied to every read of readValueAsync, including one that joins a refresh in flight.
+     * Runs once per sample of every monitored item: it allocates nothing
+     */
+    private _readDenial(context: ISessionContext): StatusCode | 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
+            // branch of _readValueAsync - which calls the getter directly and never passes
+            // through readValue(). Without this check here, a node hardened
+            // with AccessRestrictions(EncryptionRequired) answered its value
+            // over an unencrypted channel.
+            return StatusCodes.BadSecurityModeInsufficient;
+        } else if (!this.isReadable(context)) {
+            return StatusCodes.BadNotReadable;
+        } else if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
+            return 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)
+        ) {
+            return StatusCodes.BadNotReadable;
+        }
+        return null;
+    }
+
     private _readValueAsync(context: ISessionContext | null, callback: CallbackT<DataValue>, readAt?: PreciseClock): void {
         context = context || SessionContext.defaultContext;
 
         if (this.__waiting_callback) {
-            // a refresh is in progress: its value answers this read too
+            // a refresh is in progress: its value answers this read too, once this read's own
+            // access checks have passed (they depend on its context, not on the first reader's)
+            const joinerDenied = this._readDenial(context);
+            if (joinerDenied) {
+                callback(null, makeNowDataValue({ statusCode: joinerDenied }));
+                return;
+            }
             this.__more_waiting_callbacks ??= [];
             this.__more_waiting_callbacks.push(callback);
             return;
@@ -1363,28 +1426,7 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
         // 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
-            // branch below - which calls the getter directly and never passes
-            // through readValue(). Without this check here, a node hardened
-            // with AccessRestrictions(EncryptionRequired) answered its value
-            // over an unencrypted channel.
-            denied = StatusCodes.BadSecurityModeInsufficient;
-        } else if (!this.isReadable(context)) {
-            denied = StatusCodes.BadNotReadable;
-        } else if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
-            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 denied = this._readDenial(context);
 
         this.__satisfy_waiting_callbacks ??= (err: Error | null, dataValue?: DataValue) => {
             // now call all pending callbacks, in the order of the reads
@@ -1411,9 +1453,9 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
                 this.__sharedReadClock = readAt !== undefined;
                 if (this.asyncRefresh === wrappedAsyncRefresh) {
                     // the thenified wrapper adds nothing when a callback is given
-                    asyncRefreshImpl.call(this, clock, satisfy_callbacks);
+                    asyncRefreshImpl.call(this, clock, satisfy_callbacks, context);
                 } else {
-                    this.asyncRefresh(clock, satisfy_callbacks);
+                    this.asyncRefresh(clock, satisfy_callbacks, context);
                 }
                 // consumed by asyncRefresh on entry; cleared here for an overridden one that never reads it
                 this.__sharedReadClock = false;
@@ -2190,9 +2232,28 @@ import { withCallback } from "thenify-ex";
 
 // 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 asyncRefreshImpl: (
+    this: UAVariableImpl,
+    oldestDate: PreciseClock,
+    callback: CallbackT<DataValue>,
+    context?: ISessionContext
+) => void = UAVariableImpl.prototype.asyncRefresh;
+// the promise form when no callback is given, as withCallback() does: written out because that
+// wrapper takes the last argument for the callback, and the context comes after it
+UAVariableImpl.prototype.asyncRefresh = function (
+    this: UAVariableImpl,
+    oldestDate: PreciseClock,
+    callback?: CallbackT<DataValue>,
+    context?: ISessionContext
+): Promise<DataValue> | undefined {
+    if (typeof callback === "function") {
+        asyncRefreshImpl.call(this, oldestDate, callback, context);
+        return undefined;
+    }
+    return new Promise<DataValue>((resolve, reject) => {
+        asyncRefreshImpl.call(this, oldestDate, (err, dataValue) => (err ? reject(err) : resolve(dataValue as DataValue)), context);
+    });
+} as UAVariableImpl["asyncRefresh"];
 const wrappedAsyncRefresh = UAVariableImpl.prototype.asyncRefresh;
 UAVariableImpl.prototype.writeValue = withCallback(UAVariableImpl.prototype.writeValue);
 UAVariableImpl.prototype.writeAttribute = withCallback(UAVariableImpl.prototype.writeAttribute);
@@ -2337,7 +2398,8 @@ function turn_sync_to_async<T, D, R>(f: f1<T, D, R> | f2<T, D, R> | f3<T, D, R>,
             callback(null, r);
         };
     } else {
-        assert(f.length === numberOfArgs + 1);
+        // a callback-style function; it may declare the trailing context and indexRange parameters
+        assert(f.length >= numberOfArgs + 1 && f.length <= numberOfArgs + 3);
         return f;
     }
 }
@@ -2439,12 +2501,14 @@ function _Variable_bind_with_timestamped_get(
 
             throw new Error(" Bind variable error: " + " the timestamped_get function must return a DataValue");
         }
+        this._getterIsAsync = isThenable(dataValue_verify);
         _Variable_bind_with_async_refresh.call(this, { refreshFunc: async_refresh_func });
-    } else if (options.timestamped_get.length === 1) {
-        _Variable_bind_with_async_refresh.call(this, { refreshFunc: options.timestamped_get });
+    } else if (options.timestamped_get.length === 1 || options.timestamped_get.length === 2) {
+        // callback style: (callback) or (callback, context)
+        _Variable_bind_with_async_refresh.call(this, { refreshFunc: options.timestamped_get as RefreshFunc });
     } else {
-        errorLog("timestamped_get has a invalid number of argument , should be 0 or 1  ");
-        throw new Error("timestamped_get has a invalid number of argument , should be 0 or 1  ");
+        errorLog("timestamped_get has a invalid number of argument , should be 0, 1 or 2  ");
+        throw new Error("timestamped_get has a invalid number of argument , should be 0, 1 or 2  ");
     }
 }
 
@@ -2512,28 +2576,38 @@ function _Variable_bind_with_simple_set(this: UAVariableImpl, options: SimpleSet
     const set_func = turn_sync_to_async<UAVariable, Variant, StatusCode>(options.set as VariableSetter, 1);
     this._set_func = set_func;
 
-    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)");
 
+    // the trailing arguments (context, indexRange) are a rest parameter so that the length stays 2
     this._timestamped_set_func = (
         timestamped_value: DataValue,
-        callback: (err: Error | null, statusCode: StatusCode, dataValue: DataValue) => void
+        callback: (err: Error | null, statusCode: StatusCode, dataValue: DataValue) => void,
+        ...extra: [ISessionContext?, (NumericRange | null)?]
     ) => {
         assert(timestamped_value instanceof DataValue);
-        set_func.call(this, timestamped_value.value, (err: Error | null, statusCode?: StatusCode) => {
-            // c8 ignore next
-            if (!err && !statusCode) {
-                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 ?? StatusCodes.BadInternalError, timestamped_value);
-        });
+        (
+            set_func as (
+                this: UAVariable,
+                value: Variant,
+                callback: (err: Error | null, statusCode?: StatusCode) => void,
+                ...extra: unknown[]
+            ) => void
+        ).call(
+            this,
+            timestamped_value.value,
+            (err: Error | null, statusCode?: StatusCode) => {
+                // c8 ignore next
+                if (!err && !statusCode) {
+                    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);
+                }
+                callback(err, statusCode ?? StatusCodes.BadInternalError, timestamped_value);
+            },
+            ...extra
+        );
     };
 }
 
@@ -2545,7 +2619,7 @@ function _Variable_bind_with_timestamped_set(
     }
 ) {
     assert(
-        options.timestamped_set.length === 2 || options.timestamped_set.length === 1,
+        options.timestamped_set.length >= 1 && options.timestamped_set.length <= 4,
         "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 ");
@@ -2554,7 +2628,7 @@ function _Variable_bind_with_timestamped_set(
     // 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);
+        setter = convertToCallbackFunction1<StatusCode, DataValue, UAVariable>(options.timestamped_set, 2);
         callbackSetters.set(options.timestamped_set, setter);
     }
     this._timestamped_set_func = setter;
@@ -2562,12 +2636,41 @@ function _Variable_bind_with_timestamped_set(
 /** the callback form of each setter function met so far, see _Variable_bind_with_timestamped_set */
 const callbackSetters = new WeakMap<TimestampSetFunc, VariableDataValueSetterWithCallback>();
 
+/** an asynchronous setter that is told who writes (`timestamped_set_ctx`) */
+function _Variable_bind_with_context_setter(this: UAVariableImpl, setter: VariableDataValueSetterWithContext) {
+    // the context and the index range come after the callback, in a rest parameter: the length stays 2
+    this._timestamped_set_func = function (
+        this: UAVariable,
+        dataValue: DataValue,
+        callback: (err: Error | null, statusCode?: StatusCode) => void,
+        ...extra: [ISessionContext?, (NumericRange | null)?]
+    ) {
+        const [context, indexRange] = extra;
+        let promise: Promise<StatusCode>;
+        try {
+            promise = setter.call(this, dataValue, { context, indexRange });
+        } catch (err) {
+            callback(err as Error);
+            return;
+        }
+        Promise.resolve(promise).then(
+            (statusCode) => callback(null, statusCode),
+            (err) => callback(err as Error)
+        );
+    };
+}
+
 interface SetterOptions {
     set?: SetFunc;
     timestamped_set?: TimestampSetFunc;
+    timestamped_set_ctx?: VariableDataValueSetterWithContext;
     timestamped_get?: TimestampGetFunc;
+    timestamped_get_ctx?: VariableDataValueGetterWithContext;
 }
 function bind_setter(this: UAVariableImpl, options: SetterOptions) {
+    if (options.timestamped_set && options.timestamped_set_ctx) {
+        throw new Error("bind_setter : options should not specify both timestamped_set and timestamped_set_ctx ");
+    }
     if (options.set && typeof options.set === "function") {
         // variation 1
         if (options.timestamped_set === undefined) {
@@ -2582,8 +2685,15 @@ function bind_setter(this: UAVariableImpl, options: SetterOptions) {
             set: undefined,
             timestamped_set: options.timestamped_set
         });
-    } else if (typeof options.timestamped_get === "function") {
-        // timestamped_get is  specified but timestamped_set is not
+    } else if (typeof options.timestamped_set_ctx === "function") {
+        // variation 5: the setter is told who writes
+        assert(
+            typeof options.timestamped_get === "function" || typeof options.timestamped_get_ctx === "function",
+            "timestamped_set_ctx must be used with timestamped_get or timestamped_get_ctx"
+        );
+        _Variable_bind_with_context_setter.call(this, options.timestamped_set_ctx);
+    } else if (typeof options.timestamped_get === "function" || typeof options.timestamped_get_ctx === "function") {
+        // a timestamped getter is specified but no setter
         // => Value is read-only
         _Variable_bind_with_timestamped_set.call(this, {
             set: undefined,
@@ -2597,10 +2707,36 @@ function bind_setter(this: UAVariableImpl, options: SetterOptions) {
     }
 }
 
-type RefreshFunc = (callback: CallbackT<DataValue>) => void;
+type RefreshFunc = (callback: CallbackT<DataValue>, context?: ISessionContext) => void;
+/**
+ * variation 5: an asynchronous getter that is told who reads (`timestamped_get_ctx`). It is run by
+ * the refresh only, like any asynchronous getter, with the session context of the read.
+ */
+function _Variable_bind_with_context_getter(this: UAVariableImpl, getter: VariableDataValueGetterWithContext) {
+    _Variable_bind_with_async_refresh.call(this, {
+        refreshFunc: (callback: CallbackT<DataValue>, context?: ISessionContext) => {
+            let promise: Promise<DataValue>;
+            try {
+                promise = getter.call(this, { context });
+            } catch (err) {
+                callback(err as Error);
+                return;
+            }
+            Promise.resolve(promise).then(
+                (dataValue) => callback(null, dataValue),
+                (err) => {
+                    errorLog("timestamped_get_ctx error: Variable is ", this.nodeId.toString(), this.browseName.toString());
+                    callback(err as Error);
+                }
+            );
+        }
+    });
+}
+
 interface GetterOptions {
     get?: GetFunc;
     timestamped_get?: TimestampGetFunc;
+    timestamped_get_ctx?: VariableDataValueGetterWithContext;
     refreshFunc?: RefreshFunc;
     dataType?: DataType | string;
     value?: unknown;
@@ -2615,6 +2751,9 @@ function bind_getter(this: UAVariableImpl, options: GetterOptions) {
             get: undefined,
             timestamped_get: options.timestamped_get
         });
+    } else if (typeof options.timestamped_get_ctx === "function") {
+        // variation 5
+        _Variable_bind_with_context_getter.call(this, options.timestamped_get_ctx);
     } else if (typeof options.refreshFunc === "function") {
         // variation 3
         if (options.get !== undefined || options.timestamped_get !== undefined) {