node-opcua-address-space 2.182.2 → 2.183.1

package/impl/alarms_and_conditions/ua_alarm_condition_impl.ts

@@ -2,7 +2,7 @@
  * @module node-opcua-address-space.AlarmsAndConditions
  */
 import { isDeepStrictEqual as isEqual } from "node:util";
-import type { BaseNode, INamespace, UAEventType, UAProperty, UAVariable } from "node-opcua-address-space-base";
+import type { BaseNode, INamespace, UAEventType, UAObject, UAProperty, UAVariable } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { NodeClass } from "node-opcua-data-model";
 import type { DataValue } from "node-opcua-data-value";
@@ -12,6 +12,7 @@ import { StatusCodes } from "node-opcua-status-code";
 import { DataType, type VariantOptions } from "node-opcua-variant";
 import type { ConditionInfo } from "../../api/interfaces/alarms_and_conditions/condition_info_i.js";
 import type { InstantiateAlarmConditionOptions } from "../../api/interfaces/alarms_and_conditions/instantiate_alarm_condition_options.js";
+import type { PromoteToAlarmOptions } from "../../api/interfaces/alarms_and_conditions/promote_to_alarm_options.js";
 import type { UAAlarmConditionEx } from "../../api/interfaces/alarms_and_conditions/ua_alarm_condition_ex.js";
 import type { UAShelvedStateMachineEx } from "../../api/interfaces/state_machine/ua_shelved_state_machine_ex.js";
 import type { UATwoStateVariableEx } from "../../api/ua_two_state_variable_ex.js";
@@ -23,7 +24,12 @@ import {
 } from "../state_machine/ua_shelving_state_machine_ex.js";
 import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_state_variable.js";
 import { ConditionInfoImpl } from "./condition_info_impl.js";
-import { UAAcknowledgeableConditionImpl, UAAcknowledgeableConditionImplBase } from "./ua_acknowledgeable_condition_impl.js";
+import {
+    _initialize_acknowledgeable_condition_node,
+    UAAcknowledgeableConditionImpl,
+    UAAcknowledgeableConditionImplBase
+} from "./ua_acknowledgeable_condition_impl.js";
+import { _initialize_condition_node, type ConditionInitializationOptions } from "./ua_condition_impl.js";
 
 const debugLog = make_debugLog("ua_alarm_condition_impl");
 const doDebug = checkDebugFlag("ua_alarm_condition_impl");
@@ -62,6 +68,7 @@ export class UAAlarmConditionImplBase extends UAAcknowledgeableConditionImplBase
         const addressSpace = namespace.addressSpace;
         // xx assert(Object.prototype.hasOwnProperty.call(options,"conditionOf")); // must provide a conditionOf
         assert(Object.hasOwn(options, "inputNode")); // must provide a inputNode
+        assert(options.inputNode, " must provide options.inputNode (NodeId or BaseNode object)");
         const alarmConditionType = addressSpace.findEventType(alarmConditionTypeId);
 
         /* c8 ignore next */
@@ -99,114 +106,8 @@ export class UAAlarmConditionImplBase extends UAAcknowledgeableConditionImplBase
             options,
             data
         ) as unknown as UAAlarmConditionImpl;
-        Object.setPrototypeOf(alarmNode, UAAlarmConditionImpl.prototype);
-
-        // ----------------------- Install Alarm specifics
-        //
-
-        // Specs 1.03:
-        // ActiveState/Id when set to TRUE indicates that the situation the Condition is representing
-        // currently exists. When a Condition instance is in the inactive state (ActiveState/Id when set to
-        // FALSE) it is representing a situation that has returned to a normal state. The transitions of
-        // Conditions to the inactive and Active states are triggered by Server specific actions. Sub-
-        // Types of the AlarmConditionType specified later in this document will have sub-state models
-        // that further define the Active state. Recommended state names are described in Annex A.
-        // install activeState - Mandatory
-
-        /**
-         * @property activeState
-         * @type {UATwoStateVariable}
-         */
-        _install_TwoStateVariable_machinery(alarmNode.activeState, {
-            falseState: "Inactive",
-            trueState: "Active"
-        });
-
-        alarmNode.currentBranch().setActiveState(false);
-
-        // Specs 1.03:
-        /**
-         *
-         * SuppressState is used internally by a Server to automatically suppress Alarms due to system
-         * specific reasons. For example a system may be configured to suppress Alarms that are
-         * associated with machinery that is shutdown, such as a low level Alarm for a tank that is
-         * currently not in use.
-         *
-         * @property suppressedState
-         * @type UATwoStateVariable
-         */
-        if (alarmNode.suppressedState) {
-            // install activeState - Optional
-            _install_TwoStateVariable_machinery(alarmNode.suppressedState, {
-                falseState: "Unsuppressed",
-                trueState: "Suppressed"
-            });
-        }
-        // Specs 1.03:
-        /**
-         * ShelvingState suggests whether an Alarm shall (temporarily) be prevented from being
-         * displayed to the user. It is quite often used to block nuisance Alarms.
-         *
-         * @property shelvingState
-         * @type ShelvingStateMachine
-         */
-        if (alarmNode.shelvingState) {
-            UAShelvedStateMachineExImplBase.promote(alarmNode.shelvingState);
-        }
-
-        // SuppressedOrShelved : Mandatory
-        // install suppressedOrShelved automatic detection
-        /**
-         * The SuppressedState and the ShelvingState together result in the SuppressedOrShelved status of the
-         * Condition. When an Alarm is in one of the states, the SuppressedOrShelved property will be set TRUE
-         * and this Alarm is then typically not displayed by the Client. State transitions associated with the
-         * Alarm do occur, but they are not typically displayed by the Clients as long as the Alarm remains in
-         * either the Suppressed or Shelved state.
-         * The dataType is Boolean.
-         * @property suppressedState
-         * @type UAVariable
-         *
-         */
-        if (alarmNode.suppressedState) {
-            alarmNode.suppressedState.on("value_changed", (_newDataValue: DataValue) => {
-                _update_suppressedOrShelved(alarmNode);
-            });
-        }
-        if (alarmNode.shelvingState) {
-            alarmNode.shelvingState.currentState.on("value_changed", (_newDataValue: DataValue) => {
-                _update_suppressedOrShelved(alarmNode);
-            });
-        }
-        _update_suppressedOrShelved(alarmNode);
 
-        /**
-         * The optional Property MaxTimeShelved is used to set the maximum time that an Alarm Condition may be shelved.
-         * The value is expressed as duration. Systems can use this Property to prevent permanent Shelving of an Alarm.
-         * If this Property is present it will be an upper limit on the duration passed into a TimedShelve Method call.
-         * If a value that exceeds the value of this property is passed to the TimedShelve Method,
-         * than a BadShelvingTimeOutOfRange error code is returned on the call. If this Property is present it will
-         * also be enforced for the OneShotShelved state, in that an Alarm Condition will transition to the Unshelved
-         * state from the OneShotShelved state if the duration specified in this Property expires following a
-         * OneShotShelve operation without a change of any of the other items associated with the Condition.
-         *
-         * @property maxTimeShelved
-         * @type {UAVariable}
-         */
-        if (alarmNode.maxTimeShelved) {
-            options.maxTimeShelved = options.maxTimeShelved || 60.0 * 1000; // 60 seconds
-            alarmNode.maxTimeShelved.setValueFromSource({
-                dataType: "Duration",
-                value: options.maxTimeShelved
-            });
-        }
-
-        // ---------- install inputNode
-        assert(options.inputNode, " must provide options.inputNode (NodeId or BaseNode object)");
-        alarmNode.installInputNodeMonitoring(options.inputNode);
-
-        assert(alarmNode instanceof UAAcknowledgeableConditionImpl);
-        assert(alarmNode instanceof UAAlarmConditionImpl);
-        return alarmNode;
+        return _initialize_alarm_condition_node(alarmNode, options);
     }
 
     public dispose(): void {
@@ -323,10 +224,36 @@ export class UAAlarmConditionImplBase extends UAAcknowledgeableConditionImplBase
         this._onInputDataValueChange(dataValue);
     }
 
-    protected _onInputDataValueChange(_newValue: DataValue): void {
+    /**
+     * What the alarm does when the value of its input node changes. Assign to it to give an
+     * alarm a state machine of its own, without deriving from anything.
+     *
+     * @example
+     *
+     * ```ts
+     * const myAlarm = namespace.instantiateAlarmCondition("AlarmConditionType", { ... });
+     * myAlarm.onInputDataValueChange = (newValue) => {
+     *     const tooHot = newValue.value.value > 80;
+     *     if (tooHot !== myAlarm.activeState.getValue()) {
+     *         myAlarm.signalNewCondition(tooHot ? "Active" : "Inactive", tooHot, `${newValue.value.value}`);
+     *     }
+     * };
+     * ```
+     *
+     * The default does nothing: a plain AlarmConditionType has no idea what its input means.
+     * The alarm types that do (limit alarms, off-normal alarms) override this.
+     */
+    public onInputDataValueChange(_newValue: DataValue): void {
         /**  */
     }
 
+    /**
+     * @deprecated assign {@link onInputDataValueChange} instead; this delegates to it.
+     */
+    protected _onInputDataValueChange(newValue: DataValue): void {
+        this.onInputDataValueChange(newValue);
+    }
+
     /**
      * install mechanism that listen to input node datavalue changes so that alarm status
      * can be automatically updated appropriately.
@@ -464,7 +391,21 @@ export class UAAlarmConditionImplBase extends UAAcknowledgeableConditionImplBase
         this.currentBranch().setActiveState(false);
         this.currentBranch().setAckedState(true);
     }
+    /**
+     * @deprecated call {@link signalNewCondition} instead; this delegates to it.
+     */
     public _signalNewCondition(stateName: string | null, isActive: boolean, value: string): void {
+        this.signalNewCondition(stateName, isActive, value);
+    }
+
+    /**
+     * Raise a new condition event for this alarm.
+     *
+     * Call this only when the condition has actually changed: it throws when the new
+     * ConditionInfo is equal to the current one, because raising an event that reports
+     * nothing new is a bug in the caller rather than a state the alarm can represent.
+     */
+    public signalNewCondition(stateName: string | null, isActive: boolean, value: string): void {
         // xx if(stateName === null) {
         // xx     alarm.currentBranch().setActiveState(false);
         // xx     alarm.currentBranch().setAckedState(true);
@@ -480,7 +421,7 @@ export class UAAlarmConditionImplBase extends UAAcknowledgeableConditionImplBase
         // `calculateConditionInfo` is reached by the default below. Both work.
         const newConditionInfo = this._calculateConditionInfo(stateName, isActive, value, oldConditionInfo);
 
-        // detect potential internal bugs due to misused of _signalNewCondition
+        // detect potential internal bugs due to misused of signalNewCondition
         if (isEqual(oldConditionInfo, newConditionInfo)) {
             // c8 ignore next
             if (doDebug) {
@@ -523,3 +464,213 @@ export class UAAlarmConditionImplBase extends UAAcknowledgeableConditionImplBase
 export type UAAlarmConditionImpl = UAAlarmConditionImplBase;
 /** @internal */
 export const UAAlarmConditionImpl = UAAlarmConditionImplBase;
+
+/**
+ * The part of {@link InstantiateAlarmConditionOptions} that the initialization step below reads.
+ *
+ * @internal
+ */
+export type AlarmConditionInitializationOptions = ConditionInitializationOptions & {
+    maxTimeShelved?: number;
+    inputNode?: UAVariable | NodeId;
+};
+
+/**
+ * The alarm half of the wiring, everything that follows the creation of the node.
+ *
+ * Shared by {@link UAAlarmConditionImplBase.instantiate} and by {@link promoteToAlarm}, so a node
+ * that was created some other way ends up with exactly the same machinery rather than an
+ * approximation of it. `inputNode` is optional here because a node being promoted may already
+ * carry its InputNode property, or may be given one later.
+ *
+ * @internal
+ */
+export function _initialize_alarm_condition_node(
+    alarmNode: UAAlarmConditionImpl,
+    options: AlarmConditionInitializationOptions
+): UAAlarmConditionImpl {
+    Object.setPrototypeOf(alarmNode, UAAlarmConditionImpl.prototype);
+
+    // ----------------------- Install Alarm specifics
+    //
+
+    // Specs 1.03:
+    // ActiveState/Id when set to TRUE indicates that the situation the Condition is representing
+    // currently exists. When a Condition instance is in the inactive state (ActiveState/Id when set to
+    // FALSE) it is representing a situation that has returned to a normal state. The transitions of
+    // Conditions to the inactive and Active states are triggered by Server specific actions. Sub-
+    // Types of the AlarmConditionType specified later in this document will have sub-state models
+    // that further define the Active state. Recommended state names are described in Annex A.
+    // install activeState - Mandatory
+
+    /**
+     * @property activeState
+     * @type {UATwoStateVariable}
+     */
+    _install_TwoStateVariable_machinery(alarmNode.activeState, {
+        falseState: "Inactive",
+        trueState: "Active"
+    });
+
+    alarmNode.currentBranch().setActiveState(false);
+
+    // Specs 1.03:
+    /**
+     *
+     * SuppressState is used internally by a Server to automatically suppress Alarms due to system
+     * specific reasons. For example a system may be configured to suppress Alarms that are
+     * associated with machinery that is shutdown, such as a low level Alarm for a tank that is
+     * currently not in use.
+     *
+     * @property suppressedState
+     * @type UATwoStateVariable
+     */
+    if (alarmNode.suppressedState) {
+        // install activeState - Optional
+        _install_TwoStateVariable_machinery(alarmNode.suppressedState, {
+            falseState: "Unsuppressed",
+            trueState: "Suppressed"
+        });
+    }
+    // Specs 1.03:
+    /**
+     * ShelvingState suggests whether an Alarm shall (temporarily) be prevented from being
+     * displayed to the user. It is quite often used to block nuisance Alarms.
+     *
+     * @property shelvingState
+     * @type ShelvingStateMachine
+     */
+    if (alarmNode.shelvingState) {
+        UAShelvedStateMachineExImplBase.promote(alarmNode.shelvingState);
+    }
+
+    // SuppressedOrShelved : Mandatory
+    // install suppressedOrShelved automatic detection
+    /**
+     * The SuppressedState and the ShelvingState together result in the SuppressedOrShelved status of the
+     * Condition. When an Alarm is in one of the states, the SuppressedOrShelved property will be set TRUE
+     * and this Alarm is then typically not displayed by the Client. State transitions associated with the
+     * Alarm do occur, but they are not typically displayed by the Clients as long as the Alarm remains in
+     * either the Suppressed or Shelved state.
+     * The dataType is Boolean.
+     * @property suppressedState
+     * @type UAVariable
+     *
+     */
+    if (alarmNode.suppressedState) {
+        alarmNode.suppressedState.on("value_changed", (_newDataValue: DataValue) => {
+            _update_suppressedOrShelved(alarmNode);
+        });
+    }
+    if (alarmNode.shelvingState) {
+        alarmNode.shelvingState.currentState.on("value_changed", (_newDataValue: DataValue) => {
+            _update_suppressedOrShelved(alarmNode);
+        });
+    }
+    _update_suppressedOrShelved(alarmNode);
+
+    /**
+     * The optional Property MaxTimeShelved is used to set the maximum time that an Alarm Condition may be shelved.
+     * The value is expressed as duration. Systems can use this Property to prevent permanent Shelving of an Alarm.
+     * If this Property is present it will be an upper limit on the duration passed into a TimedShelve Method call.
+     * If a value that exceeds the value of this property is passed to the TimedShelve Method,
+     * than a BadShelvingTimeOutOfRange error code is returned on the call. If this Property is present it will
+     * also be enforced for the OneShotShelved state, in that an Alarm Condition will transition to the Unshelved
+     * state from the OneShotShelved state if the duration specified in this Property expires following a
+     * OneShotShelve operation without a change of any of the other items associated with the Condition.
+     *
+     * @property maxTimeShelved
+     * @type {UAVariable}
+     */
+    if (alarmNode.maxTimeShelved) {
+        options.maxTimeShelved = options.maxTimeShelved || 60.0 * 1000; // 60 seconds
+        alarmNode.maxTimeShelved.setValueFromSource({
+            dataType: "Duration",
+            value: options.maxTimeShelved
+        });
+    }
+
+    // ---------- install inputNode
+    if (options.inputNode) {
+        alarmNode.installInputNodeMonitoring(options.inputNode);
+    }
+
+    assert(alarmNode instanceof UAAcknowledgeableConditionImpl);
+    assert(alarmNode instanceof UAAlarmConditionImpl);
+    return alarmNode;
+}
+
+/**
+ * Give an existing node the behaviour of the alarm its type says it is.
+ *
+ * A node only becomes a working alarm when `namespace.instantiateAlarmCondition` builds it; a node
+ * that arrived any other way - `objectType.instantiate()`, or a nodeset XML - carries the right
+ * children but none of the machinery, so `activateAlarm` and `signalNewCondition` are simply not
+ * there. This retypes the node in place, keeping its identity in the address space index and every
+ * reference already pointing at it, and then runs the same initialization the factory runs.
+ *
+ * Limit alarms are refused rather than half-promoted: their behaviour lives in
+ * UALimitAlarmImpl and its subclasses, and a node wearing the plain alarm prototype would look
+ * promoted while ignoring its own limit set points.
+ */
+export function promoteToAlarm(node: UAObject, options?: PromoteToAlarmOptions): UAAlarmConditionEx {
+    if (node instanceof UAAlarmConditionImplBase) {
+        return node as unknown as UAAlarmConditionImpl; // already promoted
+    }
+    const addressSpace = node.addressSpace;
+    const typeDefinition = node.typeDefinitionObj;
+
+    const alarmConditionType = addressSpace.findObjectType("AlarmConditionType");
+    /* c8 ignore next */
+    if (!alarmConditionType) {
+        throw new Error("promoteToAlarm: cannot find AlarmConditionType - is the standard nodeset loaded ?");
+    }
+    if (!typeDefinition || (typeDefinition !== alarmConditionType && !typeDefinition.isSubtypeOf(alarmConditionType))) {
+        throw new Error(
+            `promoteToAlarm: ${node.browseName.toString()} has type definition ` +
+                `${typeDefinition ? typeDefinition.browseName.toString() : "<none>"} ` +
+                "which does not derive from AlarmConditionType - only alarms can be promoted"
+        );
+    }
+    const limitAlarmType = addressSpace.findObjectType("LimitAlarmType");
+    if (limitAlarmType && (typeDefinition === limitAlarmType || typeDefinition.isSubtypeOf(limitAlarmType))) {
+        throw new Error(
+            `promoteToAlarm: ${node.browseName.toString()} is a ${typeDefinition.browseName.toString()}, ` +
+                "a limit alarm - promoting limit alarms is not supported, use namespace.instantiateLimitAlarm instead"
+        );
+    }
+    // CertificateExpirationAlarmType carries behaviour of its own - promoteToCertificateExpirationAlarm
+    // starts an expiry timer and registers a shutdown task. Promoting one here would give it plain
+    // alarm behaviour and silently drop that, which is worse than refusing: the node would look
+    // promoted and never fire.
+    const certificateExpirationAlarmType = addressSpace.findObjectType("CertificateExpirationAlarmType");
+    if (
+        certificateExpirationAlarmType &&
+        (typeDefinition === certificateExpirationAlarmType || typeDefinition.isSubtypeOf(certificateExpirationAlarmType))
+    ) {
+        throw new Error(
+            `promoteToAlarm: ${node.browseName.toString()} is a ${typeDefinition.browseName.toString()}, ` +
+                "which has its own expiry machinery - use promoteToCertificateExpirationAlarm instead"
+        );
+    }
+    const alarmConditionEventType = addressSpace.findEventType(typeDefinition.nodeId);
+    /* c8 ignore next */
+    if (!alarmConditionEventType) {
+        throw new Error(`promoteToAlarm: cannot find event type for ${typeDefinition.browseName.toString()}`);
+    }
+
+    // conditionSource has to be an own property even when it is absent: the condition
+    // initialization tells "no source" from "source not considered" by its presence.
+    const initializationOptions: AlarmConditionInitializationOptions = {
+        conditionClass: options?.conditionClass,
+        conditionName: options?.conditionName || node.browseName.name || undefined,
+        conditionSource: options?.conditionSource ?? null,
+        inputNode: options?.inputNode,
+        maxTimeShelved: options?.maxTimeShelved
+    };
+
+    const conditionNode = node as unknown as UAAlarmConditionImpl;
+    _initialize_condition_node(node.namespace, conditionNode, alarmConditionEventType, initializationOptions);
+    _initialize_acknowledgeable_condition_node(conditionNode);
+    return _initialize_alarm_condition_node(conditionNode, initializationOptions);
+}

package/impl/alarms_and_conditions/ua_condition_impl.ts

@@ -749,6 +749,40 @@ function UACondition_instantiate(
         namespace: options.namespace || namespace
     };
     const conditionNode = conditionType.instantiate(options2) as unknown as UAConditionImpl;
+    return _initialize_condition_node(namespace, conditionNode, conditionType, options, data);
+}
+
+/**
+ * The part of {@link InstantiateConditionOptions} that the initialization step below reads.
+ *
+ * Named separately so a caller that is wiring an existing node - which has no browseName or
+ * parent to give - does not have to invent the creation-time half of the options.
+ *
+ * @internal
+ */
+export type ConditionInitializationOptions = Pick<
+    InstantiateConditionOptions,
+    "conditionSource" | "conditionOf" | "conditionClass" | "conditionName"
+>;
+
+/**
+ * Everything that turns a freshly created node into a working condition.
+ *
+ * Split out of {@link UACondition_instantiate} so that a node that already exists - one built by
+ * `objectType.instantiate` or loaded from a nodeset - can be given the very same wiring without
+ * being rebuilt, and so the two routes cannot drift apart.
+ *
+ * @internal
+ */
+export function _initialize_condition_node(
+    namespace: INamespace,
+    conditionNode: UAConditionImpl,
+    conditionType: UAEventType,
+    options: ConditionInitializationOptions,
+    data?: Record<string, VariantOptions>
+): UAConditionEx {
+    const addressSpace = namespace.addressSpace as AddressSpacePrivate;
+
     Object.setPrototypeOf(conditionNode, UAConditionImpl.prototype);
     conditionNode.initialize();
 
@@ -1075,9 +1109,11 @@ function _condition_refresh_method(
     }
     const subscriptionId = inputArguments[0].value;
 
+    // a rejected argument is answered in the Call result, never thrown: the Call service
+    // turns an exception into Bad_InternalError and the CTT reads that as a broken server
     let statusCode = _check_subscription_id_is_valid(subscriptionId, context);
     if (statusCode.isNotGood()) {
-        return statusCode;
+        return callback(null, { statusCode });
     }
 
     statusCode = _perform_condition_refresh(addressSpace, inputArguments, context);
@@ -1090,6 +1126,7 @@ function _perform_condition_refresh(addressSpace: AddressSpacePrivate, _inputArg
     // --- possible StatusCodes:
     //
     // Bad_SubscriptionIdInvalid  See Part 4 for the description of this result code
+    //                            (checked by the caller, before we get here)
     // Bad_RefreshInProgress      See Table 74 for the description of this result code
     // Bad_UserAccessDenied       The Method was not called in the context of the Session
     //                            that owns the Subscription
@@ -1101,8 +1138,6 @@ function _perform_condition_refresh(addressSpace: AddressSpacePrivate, _inputArg
         return StatusCodes.BadRefreshInProgress;
     }
 
-    addressSpace._condition_refresh_in_progress = true;
-
     const server = context.object?.addressSpace.rootFolder.objects.server;
     const refreshStartEventType = addressSpace.findEventType("RefreshStartEventType");
     if (!refreshStartEventType) {
@@ -1113,17 +1148,21 @@ function _perform_condition_refresh(addressSpace: AddressSpacePrivate, _inputArg
         throw new Error("cannot find RefreshEndEventType");
     }
 
-    server?.raiseEvent(refreshStartEventType, {});
-    // todo : resend retained conditions
-
-    const _server = server as unknown as { _conditionRefresh: () => void };
-    // starting from server object ..
-    // evaluated all --> hasNotifier/hasEventSource -> node
-    _server._conditionRefresh();
-
-    server?.raiseEvent(refreshEndEventType, {});
-
-    addressSpace._condition_refresh_in_progress = false;
+    addressSpace._condition_refresh_in_progress = true;
+    try {
+        server?.raiseEvent(refreshStartEventType, {});
+
+        const _server = server as unknown as { _conditionRefresh: () => void };
+        // starting from server object ..
+        // evaluated all --> hasNotifier/hasEventSource -> node
+        _server._conditionRefresh();
+
+        server?.raiseEvent(refreshEndEventType, {});
+    } finally {
+        // whatever a condition's event handler throws, the next refresh must not be
+        // answered Bad_RefreshInProgress for ever
+        addressSpace._condition_refresh_in_progress = false;
+    }
 
     return StatusCodes.Good;
 }
@@ -1146,10 +1185,19 @@ function _condition_refresh2_method(
         debugLog(chalk.cyan.bgWhite(" ConditionType.conditionRefresh2 !"));
     }
 
-    // xx var subscriptionId = inputArguments[0].value;
-    // xx var monitoredItemId = inputArguments[1].value;
+    const subscriptionId = inputArguments[0].value;
+    const monitoredItemId = inputArguments[1].value;
 
-    const statusCode = _perform_condition_refresh(addressSpace, inputArguments, context);
+    let statusCode = _check_subscription_id_is_valid(subscriptionId, context);
+    if (statusCode.isNotGood()) {
+        return callback(null, { statusCode });
+    }
+    statusCode = _check_monitored_item_id_is_valid(subscriptionId, monitoredItemId, context);
+    if (statusCode.isNotGood()) {
+        return callback(null, { statusCode });
+    }
+
+    statusCode = _perform_condition_refresh(addressSpace, inputArguments, context);
     return callback(null, {
         statusCode
     });
@@ -1280,7 +1328,33 @@ function _getCompositeKey(node: BaseNode, key: string): UAVariableImpl {
  * @param context {Object}
  * @private
  */
-function _check_subscription_id_is_valid(_subscriptionId: number, _context: ISessionContext) {
-    /// todo: return StatusCodes.BadSubscriptionIdInvalid; if subscriptionId doesn't belong to session...
-    return StatusCodes.Good;
+function _check_subscription_id_is_valid(subscriptionId: number, context: ISessionContext): StatusCode {
+    // Part 9 5.5.7: Bad_SubscriptionIdInvalid when the SubscriptionId is not one of the
+    // calling Session's. A Subscription of another Session is not reachable from this one
+    // (Part 4: SubscriptionIds are Session-scoped), so it gets the same answer.
+    const session = context.session;
+    if (!session || typeof session.getSubscription !== "function") {
+        // no Session behind the call (an in-process caller, a PseudoSession, a unit test):
+        // there is nothing to check the argument against
+        return StatusCodes.Good;
+    }
+    return session.getSubscription(subscriptionId) ? StatusCodes.Good : StatusCodes.BadSubscriptionIdInvalid;
+}
+
+/**
+ * ConditionRefresh2 (Part 9 5.5.8): the MonitoredItemId must name a MonitoredItem of the
+ * given Subscription, else Bad_MonitoredItemIdInvalid. Call after
+ * _check_subscription_id_is_valid, which has established that the Subscription is ours.
+ * @private
+ */
+function _check_monitored_item_id_is_valid(subscriptionId: number, monitoredItemId: number, context: ISessionContext): StatusCode {
+    const session = context.session;
+    if (!session || typeof session.getSubscription !== "function") {
+        return StatusCodes.Good;
+    }
+    const subscription = session.getSubscription(subscriptionId);
+    if (!subscription) {
+        return StatusCodes.BadSubscriptionIdInvalid;
+    }
+    return subscription.getMonitoredItem(monitoredItemId) ? StatusCodes.Good : StatusCodes.BadMonitoredItemIdInvalid;
 }

package/impl/alarms_and_conditions/ua_exclusive_deviation_alarm_impl.ts

@@ -70,22 +70,33 @@ export class UAExclusiveDeviationAlarmImplBase extends UAExclusiveLimitAlarmImpl
         return DeviationAlarmHelper_getSetpointValue.call(this);
     }
 
-    public _onSetpointDataValueChange(dataValue: DataValue): void {
+    /**
+     * What the alarm does when the value of its setpoint node changes: re-evaluate the state
+     * of the alarm against the new setpoint, since the deviation it watches has just moved.
+     */
+    public onSetpointDataValueChange(dataValue: DataValue): void {
         DeviationAlarmHelper_onSetpointDataValueChange.call(this, dataValue);
     }
 
+    /**
+     * @deprecated assign {@link onSetpointDataValueChange} instead; this delegates to it.
+     */
+    public _onSetpointDataValueChange(dataValue: DataValue): void {
+        this.onSetpointDataValueChange(dataValue);
+    }
+
     public _install_setpoint(options: InstallSetPointOptions): void {
         DeviationAlarmHelper_install_setpoint.call(this, options);
     }
 
-    public _setStateBasedOnInputValue(value: number): void {
+    public setStateBasedOnInputValue(value: number): void {
         const setpointValue = this.getSetpointValue();
         if (setpointValue === null) {
             return;
         }
         assert(Number.isFinite(setpointValue));
         // call base class implementation
-        UAExclusiveLimitAlarmImpl.prototype._setStateBasedOnInputValue.call(this, value - setpointValue);
+        UAExclusiveLimitAlarmImpl.prototype.setStateBasedOnInputValue.call(this, value - setpointValue);
     }
 }
 /** @internal */

package/impl/alarms_and_conditions/ua_exclusive_limit_alarm_impl.ts

@@ -62,7 +62,7 @@ export class UAExclusiveLimitAlarmImplBase extends UALimitAlarmImpl implements U
 
         return alarm as UAExclusiveLimitAlarmImpl;
     }
-    public _signalNewCondition(stateName: string | null, isActive: boolean, value: string): void {
+    public signalNewCondition(stateName: string | null, isActive: boolean, value: string): void {
         assert(stateName === null || typeof isActive === "boolean");
         assert(validState.indexOf(stateName) >= 0, `must have a valid state : ${stateName}`);
 
@@ -75,10 +75,10 @@ export class UAExclusiveLimitAlarmImplBase extends UALimitAlarmImpl implements U
             assert(stateName === null);
             this.limitState.setState(stateName);
         }
-        super._signalNewCondition(stateName, isActive, value);
+        super.signalNewCondition(stateName, isActive, value);
     }
 
-    public _setStateBasedOnInputValue(value: number): void {
+    public setStateBasedOnInputValue(value: number): void {
         assert(Number.isFinite(value));
         let isActive = false;
 
@@ -101,7 +101,7 @@ export class UAExclusiveLimitAlarmImplBase extends UALimitAlarmImpl implements U
         }
 
         if (state !== oldState) {
-            this._signalNewCondition(state, isActive, value.toFixed(3));
+            this.signalNewCondition(state, isActive, value.toFixed(3));
         }
     }
 }