node-opcua-client 2.177.0 → 2.179.0

package/source/private/client_subscription_impl.ts

@@ -1,7 +1,6 @@
 /**
  * @module node-opcua-client-private
  */
-// tslint:disable:unified-signatures
 
 import { EventEmitter } from "node:events";
 import chalk from "chalk";
@@ -51,6 +50,7 @@ import type { ClientSessionImpl } from "./client_session_impl";
 interface ModifySubscriptionOptionsEx extends ModifySubscriptionOptions {
     subscriptionId?: SubscriptionId;
 }
+
 import { detectLongOperation } from "./performance";
 
 const debugLog = make_debugLog("CLIENT_SUBSCRIPTION");
@@ -249,12 +249,10 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
     public terminate(): Promise<void>;
     public terminate(callback: ErrorCallback): void;
     public terminate(callback?: ErrorCallback): Promise<void> | void {
-        debugLog("Terminating client subscription ", this.subscriptionId);
+        // c8 ignore next
+        doDebug && debugLog("Terminating client subscription ", this.subscriptionId);
 
-        if (
-            this.subscriptionId === TERMINATED_SUBSCRIPTION_ID ||
-            this.subscriptionId === TERMINATING_SUBSCRIPTION_ID
-        ) {
+        if (this.subscriptionId === TERMINATED_SUBSCRIPTION_ID || this.subscriptionId === TERMINATING_SUBSCRIPTION_ID) {
             // already terminated... just ignore
             callback?.();
             return;
@@ -279,7 +277,8 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
                 },
                 (err: Error | null, response?: DeleteSubscriptionsResponse) => {
                     if (response && response?.results?.[0] !== StatusCodes.Good) {
-                        debugLog("warning: deleteSubscription returned ", response.results);
+                        // c8 ignore next
+                        doDebug && debugLog("warning: deleteSubscription returned ", response.results);
                     }
                     if (err) {
                         /**
@@ -293,7 +292,8 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
                 }
             );
         } else {
-            debugLog("subscriptionId is not value ", this.subscriptionId);
+            // c8 ignore next
+            doDebug && debugLog("subscriptionId is not value ", this.subscriptionId);
             assert(this.subscriptionId === PENDING_SUBSCRIPTION_ID);
             this._terminate_step2(callback as ErrorCallback);
         }
@@ -332,7 +332,6 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
         monitoringMode?: MonitoringMode | Callback<ClientMonitoredItemBase>,
         callback?: Callback<ClientMonitoredItemBase>
     ): Promise<ClientMonitoredItemBase> | undefined {
-
         // When called with 3 args via the promise API, thenify
         // injects its callback as the 4th argument (the
         // monitoringMode slot).  Detect this and shift.
@@ -378,7 +377,6 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
         timestampsToReturn: TimestampsToReturn,
         callback?: Callback<ClientMonitoredItemGroup>
     ): Promise<ClientMonitoredItemGroup> | undefined {
-
         const monitoredItemGroup = new ClientMonitoredItemGroupImpl(this, itemsToMonitor, requestedParameters, timestampsToReturn);
 
         this._wait_for_subscription_to_be_ready((err?: Error) => {
@@ -397,10 +395,7 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
         return undefined;
     }
 
-    public _delete_monitored_items(
-        monitoredItems: ClientMonitoredItemBase[],
-        callback: ErrorCallback
-    ): void {
+    public _delete_monitored_items(monitoredItems: ClientMonitoredItemBase[], callback: ErrorCallback): void {
         assert(typeof callback === "function");
         assert(Array.isArray(monitoredItems));
 
@@ -423,10 +418,7 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
 
     public async setPublishingMode(publishingEnabled: boolean): Promise<StatusCode>;
     public setPublishingMode(publishingEnabled: boolean, callback: Callback<StatusCode>): void;
-    public setPublishingMode(
-        publishingEnabled: boolean, callback?: Callback<StatusCode>
-    ): Promise<StatusCode> | undefined {
-
+    public setPublishingMode(publishingEnabled: boolean, callback?: Callback<StatusCode>): Promise<StatusCode> | undefined {
         const session = this.session as ClientSessionImpl;
         if (!session) {
             callback?.(new Error("no session"));
@@ -703,14 +695,16 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
     private __on_publish_response_StatusChangeNotification(notification: StatusChangeNotification) {
         assert(notification.schema.name === "StatusChangeNotification");
 
-        debugLog("Client has received a Status Change Notification ", notification.status.toString());
+        // c8 ignore next
+        doDebug && debugLog("Client has received a Status Change Notification ", notification.status.toString());
 
         if (notification.status === StatusCodes.GoodSubscriptionTransferred) {
             // OPCUA UA Spec 1.0.3 : part 3 - page 82 - 5.13.7 TransferSubscriptions:
             // If the Server transfers the Subscription to the new Session, the Server shall issue
             // a StatusChangeNotification  notificationMessage with the status code
             // Good_SubscriptionTransferred to the old Session.
-            debugLog("ClientSubscription#__on_publish_response_StatusChangeNotification : GoodSubscriptionTransferred");
+            // c8 ignore next
+            doDebug && debugLog("ClientSubscription#__on_publish_response_StatusChangeNotification : GoodSubscriptionTransferred");
 
             // may be it has been transferred after a reconnection.... in this case should do nothing about it
         }
@@ -765,7 +759,8 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
 
         if (notificationData.length === 0) {
             // this is a keep alive message
-            debugLog(chalk.yellow("Client : received a keep alive notification from client"));
+            // c8 ignore next
+            doDebug && debugLog(chalk.yellow("Client : received a keep alive notification from client"));
             /**
              * notify the observers that a keep alive Publish Response has been received from the server.
              * @event keepalive
@@ -818,7 +813,8 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
                         if (s(this).$_slowNotifCount > 0 && s(this).$_slowNotifCount % 1000 !== 0) return;
                         s(this).$_slowNotifCount++;
                         warningLog(
-                            `[NODE-OPCUA-W32]}: monitored.item event handler takes too much time : operation duration ${duration} ms [repeated ${s(this).$_slowNotifCount
+                            `[NODE-OPCUA-W32]}: monitored.item event handler takes too much time : operation duration ${duration} ms [repeated ${
+                                s(this).$_slowNotifCount
                             } times]\n         please ensure that your monitoredItem event handler is not blocking the event loop.`
                         );
                     }
@@ -935,8 +931,6 @@ export function ClientMonitoredItem_create(
     return monitoredItem;
 }
 
-// tslint:disable:no-var-requires
-// tslint:disable:max-line-length
 import { withCallback } from "thenify-ex";
 
 const _opts = { multiArgs: false };
@@ -960,7 +954,8 @@ export function __create_subscription(subscription: ClientSubscriptionImpl, call
     }
     const session = subscription.session;
 
-    debugLog(chalk.yellow.bold("ClientSubscription created "));
+    // c8 ignore next
+    doDebug && debugLog(chalk.yellow.bold("ClientSubscription created "));
 
     const request = new CreateSubscriptionRequest({
         maxNotificationsPerPublish: subscription.maxNotificationsPerPublish,

package/source/private/i_private_client.ts

@@ -15,7 +15,7 @@ export interface IClientBase {
         callback: (err: Error | null, session?: ClientSessionImpl) => void
     ): void;
     _removeSession(session: ClientSessionImpl): void;
-    closeSession(session: ClientSession, deleteSubscription: any, arg2: (err?: Error | undefined) => void): void;
+    closeSession(session: ClientSession, deleteSubscription: boolean, arg2: (err?: Error | undefined) => void): void;
 
     performMessageTransaction(request: Request, callback: ResponseCallback<Response>): void;
     endpoint?: EndpointDescription;

package/source/private/opcua_client_impl.ts

@@ -7,10 +7,10 @@ import { callbackify } from "node:util";
 import chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
-import { createFastUninitializedBuffer } from "node-opcua-buffer-utils";
 import { DataTypeExtractStrategy } from "node-opcua-client-dynamic-extension-object";
 import {
     type Certificate,
+    combine_der,
     exploreCertificate,
     extractPublicKeyFromCertificateSync,
     makePrivateKeyFromPem,
@@ -351,7 +351,7 @@ function createUserNameIdentityToken(
     });
 
     // now encrypt password as requested
-    const lenBuf = createFastUninitializedBuffer(4);
+    const lenBuf = Buffer.allocUnsafe(4);
     lenBuf.writeUInt32LE(identityToken.password.length + serverNonce.length, 0);
     const block = Buffer.concat([lenBuf, identityToken.password, serverNonce]);
     identityToken.password = cryptoFactory.asymmetricEncrypt(block, publicKey);
@@ -607,7 +607,6 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
      *
      * const create
      */
-    // biome-ignore lint/suspicious/useAdjacentOverloadSignatures: static vs instance method
     public static async createSession(
         endpointUrl: string,
         userIdentity?: UserIdentityInfo,
@@ -745,7 +744,8 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
 
         const old_client = internalSession._client;
 
-        debugLog("OPCUAClientImpl#reactivateSession");
+        // c8 ignore next
+        doDebug && debugLog("OPCUAClientImpl#reactivateSession");
 
         this._activateSession(
             internalSession,
@@ -839,7 +839,8 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
         this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
             /* c8 ignore next */
             if (err) {
-                debugLog("__createSession_step3 has failed", err.message);
+                // c8 ignore next
+                doDebug && debugLog("__createSession_step3 has failed", err.message);
                 return callback(err);
                 //                 // we could have an invalid state here or a connection error
                 //                 errorLog("error: ", err.message, " retrying in ... 5 secondes");
@@ -882,7 +883,8 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
             session.serverCertificate = response.serverCertificate;
             session.serverSignature = response.serverSignature;
 
-            debugLog("revised session timeout = ", session.timeout, response.revisedSessionTimeout);
+            // c8 ignore next
+            doDebug && debugLog("revised session timeout = ", session.timeout, response.revisedSessionTimeout);
 
             response.serverEndpoints = response.serverEndpoints || [];
 
@@ -928,6 +930,21 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
             return;
         }
 
+        // `session.serverCertificate` is captured once, at CreateSession. If the
+        // server has rotated its certificate since (push certificate management,
+        // OPC UA Part 12), the client has already re-learned the current one in
+        // fetchServerCertificate() while reconnecting — but the session still
+        // holds the old one. Both the clientSignature below and the encryption
+        // of a password-bearing user identity token are computed against it,
+        // so re-activating the existing session on the new channel would fail
+        // (BadApplicationSignatureInvalid on the server) and force a needless
+        // CreateSession. Refresh it from the client's current knowledge first.
+        // Only overwrite when the client actually knows a certificate: over a
+        // SecurityMode.None channel this.serverCertificate may be unset while
+        // the session's copy (from CreateSessionResponse) is still needed to
+        // encrypt the user token.
+        this.#refreshSessionServerCertificate(session);
+
         const serverCertificate = session.serverCertificate;
         // If the securityPolicyUri is None and none of the UserTokenPolicies requires encryption,
         // the Client shall ignore the ApplicationInstanceCertificate (serverCertificate)
@@ -1011,6 +1028,11 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
             session.lastRequestSentTime = new Date();
 
             this.performMessageTransaction(request, (err1: Error | null, response?: Response) => {
+                // this path bypasses ClientSessionImpl._performMessageTransaction, so it has to
+                // record the contact itself - and under the same rule, not a stricter one: a
+                // server that answers and rejects the activation is still a server we reached.
+                session.noteServerAnswer(err1, response);
+
                 if (!err1 && response && response.responseHeader.serviceResult.isGoodish()) {
                     /* c8 ignore next */
                     if (!(response instanceof ActivateSessionResponse)) {
@@ -1025,7 +1047,6 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
                     // OPC 10000-18 §5.2.8) so a Client can react without server access.
                     session.lastActivateSessionStatusCode = response.responseHeader.serviceResult;
                     session.serverNonce = response.serverNonce;
-                    session.lastResponseReceivedTime = new Date();
                     if (this.keepSessionAlive) {
                         session.startKeepAliveManager(this.keepAliveInterval);
                     }
@@ -1045,6 +1066,29 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
             });
         });
     }
+    /**
+     * Bring `session.serverCertificate` in line with the server certificate the
+     * client currently knows (see the comment in {@link _activateSession}).
+     * No-op when the client has no certificate of its own to offer.
+     * @private
+     */
+    #refreshSessionServerCertificate(session: ClientSessionImpl): void {
+        const current = this.serverCertificate;
+        if (!current || current.length === 0) {
+            return;
+        }
+        const currentDer = Array.isArray(current) ? combine_der(current) : current;
+        if (session.serverCertificate?.equals(currentDer)) {
+            return;
+        }
+        doDebug &&
+            debugLog(
+                "refreshing session.serverCertificate before ActivateSession (server certificate changed since CreateSession)",
+                session.sessionId.toString()
+            );
+        session.serverCertificate = currentDer;
+    }
+
     /**
      *
      * @private
@@ -1256,8 +1300,6 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
     }
 }
 
-// tslint:disable:no-var-requires
-// tslint:disable:max-line-length
 import { withCallback } from "thenify-ex";
 
 /**

package/source/private/reconnection/client_publish_engine_reconnection.ts

@@ -39,10 +39,7 @@ function extractStatusCode(err: Error | null | undefined, response?: RepublishRe
     return StatusCodes.Bad;
 }
 
-function _sendRepublish(
-    session: ClientSessionImpl,
-    subscription: ClientSubscriptionImpl
-): Promise<{ isDone: boolean }> {
+function _sendRepublish(session: ClientSessionImpl, subscription: ClientSubscriptionImpl): Promise<{ isDone: boolean }> {
     return new Promise<{ isDone: boolean }>((resolve, reject) => {
         assert(Number.isFinite(subscription.lastSequenceNumber) && subscription.lastSequenceNumber + 1 >= 0);
 
@@ -63,7 +60,8 @@ function _sendRepublish(
         }
 
         if (!session || session._closeEventHasBeenEmitted) {
-            debugLog("ClientPublishEngine#_republish aborted ");
+            // c8 ignore next
+            doDebug && debugLog("ClientPublishEngine#_republish aborted ");
             return resolve({ isDone: true });
         }
 
@@ -89,16 +87,14 @@ function _sendRepublish(
             if (!err) {
                 err = new Error(response.responseHeader.serviceResult.toString());
             }
-            debugLog(" _send_republish ends with ", err.message);
+            // c8 ignore next
+            doDebug && debugLog(" _send_republish ends with ", err.message);
             reject(err);
         });
     });
 }
 
-async function _republish(
-    engine: ClientSidePublishEngine,
-    subscription: ClientSubscriptionImpl
-): Promise<void> {
+async function _republish(engine: ClientSidePublishEngine, subscription: ClientSubscriptionImpl): Promise<void> {
     const session = engine.session as ClientSessionImpl;
 
     // loop until done (all messages re-published or error)
@@ -110,14 +106,14 @@ async function _republish(
         isDone = result.isDone;
     }
 
-    debugLog("nbPendingPublishRequest = ", engine.nbPendingPublishRequests);
-    debugLog(" _republish ends with ", "null");
+    // c8 ignore next
+    if (doDebug) {
+        debugLog("nbPendingPublishRequest = ", engine.nbPendingPublishRequests);
+        debugLog(" _republish ends with ", "null");
+    }
 }
 
-async function __askSubscriptionRepublish(
-    engine: ClientSidePublishEngine,
-    subscription: ClientSubscriptionImpl
-): Promise<void> {
+async function __askSubscriptionRepublish(engine: ClientSidePublishEngine, subscription: ClientSubscriptionImpl): Promise<void> {
     try {
         await _republish(engine, subscription);
     } catch (err) {
@@ -131,7 +127,8 @@ async function __askSubscriptionRepublish(
 
         const error = err as Error;
 
-        debugLog("__askSubscriptionRepublish--------------------- err =", error.message);
+        // c8 ignore next
+        doDebug && debugLog("__askSubscriptionRepublish--------------------- err =", error.message);
 
         if (error.message.match(/BadSessionInvalid/)) {
             // _republish failed because session is not valid anymore on server side.
@@ -147,9 +144,11 @@ async function __askSubscriptionRepublish(
             // In this case, Client must recreate a subscription and recreate monitored item without altering
             // the event handlers
             //
-            debugLog(
-                chalk.bgWhite.red("__askSubscriptionRepublish failed " + " subscriptionId is not valid anymore on server side.")
-            );
+            // c8 ignore next
+            doDebug &&
+                debugLog(
+                    chalk.bgWhite.red("__askSubscriptionRepublish failed " + " subscriptionId is not valid anymore on server side.")
+                );
             await recreateSubscriptionAndMonitoredItem(subscription);
             return;
         }
@@ -185,5 +184,7 @@ export function republish(engine: ClientSidePublishEngine, callback: () => void)
         }
     };
 
-    processAll().then(() => callback()).catch(() => callback());
+    processAll()
+        .then(() => callback())
+        .catch(() => callback());
 }

package/source/private/reconnection/client_subscription_reconnection.ts

@@ -13,7 +13,7 @@ import {
     type CreateMonitoredItemsResponse,
     type MonitoredItemCreateRequestOptions
 } from "node-opcua-types";
-import type { ClientSubscription } from "../../client_subscription";
+import type { ClientMonitoredItemBaseMap, ClientSubscription } from "../../client_subscription";
 import type { ClientMonitoredItemImpl } from "../client_monitored_item_impl";
 import { __create_subscription, type ClientSubscriptionImpl, TERMINATED_SUBSCRIPTION_ID } from "../client_subscription_impl";
 import { _shouldNotContinue } from "./reconnection";
@@ -35,7 +35,7 @@ async function createMonitoredItemsAndRespectOperationalLimits(
     return createMonitoredItemResponse;
 }
 
-async function adjustMonitoredItemNodeIds(subscription: ClientSubscription, oldMonitoredItems: any) {
+async function adjustMonitoredItemNodeIds(_subscription: ClientSubscription, _oldMonitoredItems: ClientMonitoredItemBaseMap) {
     // to Do
 }
 /**
@@ -43,11 +43,13 @@ async function adjustMonitoredItemNodeIds(subscription: ClientSubscription, oldM
 
  */
 export async function recreateSubscriptionAndMonitoredItem(_subscription: ClientSubscription): Promise<void> {
-    debugLog("recreateSubscriptionAndMonitoredItem", _subscription.subscriptionId.toString());
+    // c8 ignore next
+    doDebug && debugLog("recreateSubscriptionAndMonitoredItem", _subscription.subscriptionId.toString());
 
     const subscription = _subscription as ClientSubscriptionImpl;
     if (subscription.subscriptionId === TERMINATED_SUBSCRIPTION_ID) {
-        debugLog("Subscription is not in a valid state");
+        // c8 ignore next
+        doDebug && debugLog("Subscription is not in a valid state");
         return;
     }
 
@@ -63,9 +65,10 @@ export async function recreateSubscriptionAndMonitoredItem(_subscription: Client
         throw _err;
     }
 
-    const test = subscription.publishEngine.getSubscription(subscription.subscriptionId);
+    const _test = subscription.publishEngine.getSubscription(subscription.subscriptionId);
 
-    debugLog("recreating ", Object.keys(oldMonitoredItems).length, " monitored Items");
+    // c8 ignore next
+    doDebug && debugLog("recreating ", Object.keys(oldMonitoredItems).length, " monitored Items");
     // re-create monitored items
     const itemsToCreate: MonitoredItemCreateRequestOptions[] = [];
 
@@ -92,7 +95,8 @@ export async function recreateSubscriptionAndMonitoredItem(_subscription: Client
         throw new Error("no session");
     }
 
-    debugLog("Recreating ", itemsToCreate.length, " monitored items");
+    // c8 ignore next
+    doDebug && debugLog("Recreating ", itemsToCreate.length, " monitored items");
 
     const response = await createMonitoredItemsAndRespectOperationalLimits(session, createMonitorItemsRequest);
     const monitoredItemResults = response.results || [];
@@ -101,7 +105,7 @@ export async function recreateSubscriptionAndMonitoredItem(_subscription: Client
     monitoredItemResults.forEach((monitoredItemResult, index) => {
         const itemToCreate = itemsToCreate[index];
         /* c8 ignore next */
-        if (!itemToCreate || !itemToCreate.requestedParameters) {
+        if (!itemToCreate?.requestedParameters) {
             _errCount++;
             return;
         }

package/source/private/reconnection/reconnection.ts

@@ -2,7 +2,6 @@
  * @module node-opcua-client-private
  */
 
-// tslint:disable:only-arrow-functions
 import chalk from "chalk";
 import { assert } from "node-opcua-assert";
 import { invalidateExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object";
@@ -158,7 +157,10 @@ function _ask_for_subscription_republish(session: ClientSessionImpl, callback: (
         if (err) {
             warningLog("republish has failed with error :", err.message);
             doDebug && debugLog("_ask_for_subscription_republish has :  recreating subscription");
-            return repair_client_session_by_recreating_a_new_session(session._client!, session, callback);
+            if (!session._client) {
+                return callback(new Error("_ask_for_subscription_republish: session has no client"));
+            }
+            return repair_client_session_by_recreating_a_new_session(session._client, session, callback);
         }
 
         // Republish has completed: resume normal Publish handling. During the connection break the
@@ -206,7 +208,11 @@ function activate_session(client: IClientBase, session: ClientSessionImpl, newSe
 
         doDebug && debugLog(chalk.bgWhite.red("    => activating a new session ...."));
 
-        client._activateSession(newSession, newSession.userIdentityInfo!, (err: Error | null, _session1?: ClientSessionImpl) => {
+        if (!newSession.userIdentityInfo) {
+            reject(new Error("activate_session: newSession has no userIdentityInfo"));
+            return;
+        }
+        client._activateSession(newSession, newSession.userIdentityInfo, (err: Error | null, _session1?: ClientSessionImpl) => {
             // c8 ignore next
             doDebug && debugLog("    =>  activating a new session .... Done err=", err ? err.message : "null");
             if (err) {
@@ -467,11 +473,16 @@ function _repair_client_session(client: IClientBase, session: ClientSessionImpl,
     {
         const err = _shouldNotContinue(session);
         if (err) {
-            return callback(err);
+            callback(err);
+            return;
         }
     }
 
-    client._activateSession(session, session.userIdentityInfo!, (err: Error | null, _session2?: ClientSessionImpl) => {
+    if (!session.userIdentityInfo) {
+        callback(new Error("_repair_client_session: session has no userIdentityInfo"));
+        return;
+    }
+    client._activateSession(session, session.userIdentityInfo, (err: Error | null, _session2?: ClientSessionImpl) => {
         // prettier-ignore
         {
             const err = _shouldNotContinue(session);
@@ -499,17 +510,24 @@ type EmptyCallback = (err?: Error) => void;
 export function repair_client_session(client: IClientBase, session: ClientSessionImpl, callback: EmptyCallback): void {
     if (!client) {
         doDebug && debugLog("Aborting reactivation of old session because user requested session to be close");
-        return callback();
+        callback();
+        return;
     }
     doDebug && debugLog(chalk.yellow("Starting client session repair"));
 
     const privateSession = session as unknown as Reconnectable;
-    privateSession._reconnecting = privateSession._reconnecting || { reconnecting: false, pendingCallbacks: [] };
+    privateSession._reconnecting = privateSession._reconnecting || {
+        reconnecting: false,
+        pendingCallbacks: [],
+        pendingTransactions: []
+    };
 
     if (session.hasBeenClosed()) {
         privateSession._reconnecting.reconnecting = false;
         doDebug && debugLog("Aborting reactivation of old session because session has been closed");
-        return callback();
+        session.flushPendingTransactions(new Error("Session has been closed while the transaction was waiting for reconnection"));
+        callback();
+        return;
     }
     if (privateSession._reconnecting.reconnecting) {
         doDebug && debugLog(chalk.bgCyan("Reconnection is already happening for session"), session.sessionId.toString());
@@ -519,9 +537,6 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
 
     privateSession._reconnecting.reconnecting = true;
 
-    // get old transaction queue ...
-    const transactionQueue = privateSession._reconnecting.pendingTransactions.splice(0);
-
     const repeatedAction = (callback: EmptyCallback) => {
         // prettier-ignore
         {
@@ -579,15 +594,17 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
     repeatedAction((err) => {
         privateSession._reconnecting.reconnecting = false;
         const otherCallbacks = privateSession._reconnecting.pendingCallbacks.splice(0);
-        // re-inject element in queue
 
-        // c8 ignore next
-        if (transactionQueue.length > 0) {
-            doDebug && debugLog(chalk.yellow("re-injecting transaction queue"), transactionQueue.length);
-            transactionQueue.forEach((e) => privateSession._reconnecting.pendingTransactions.push(e));
-        }
-        otherCallbacks.forEach((c: EmptyCallback) => c(err));
+        otherCallbacks.forEach((c: EmptyCallback) => {
+            c(err);
+        });
         callback(err);
+
+        // Resolve what the application asked for while the channel was down - after the repair
+        // callbacks have run, so the session is fully usable by the time anything is replayed.
+        // On failure they are failed rather than held across the client's retry delay: a caller
+        // waiting without bound is worse than an error it can act on.
+        session.flushPendingTransactions(err ?? null);
     });
 }
 

package/source/reverse/client_reverse_connect.ts

@@ -23,6 +23,7 @@
 import { createServer, type Server, type Socket } from "node:net";
 
 import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
+import type { StatusCode } from "node-opcua-status-code";
 import {
     decodeReverseHello,
     type IAcceptedReverseConnection,
@@ -33,7 +34,6 @@ import {
     StatusCodes2,
     TCPErrorMessage
 } from "node-opcua-transport";
-import type { StatusCode } from "node-opcua-status-code";
 
 const doDebug = checkDebugFlag("ReverseConnect");
 const debugLog = make_debugLog("ReverseConnect");
@@ -193,7 +193,10 @@ export class ClientReverseConnect {
      * Register interest in the next reverse connection matching `expectation`.
      * The callback fires once with an accepted, RHE-validated connection (or an error).
      */
-    public waitForConnection(expectation: ReverseConnectExpectation | undefined, callback: AcceptedCallback): ICancelableRegistration {
+    public waitForConnection(
+        expectation: ReverseConnectExpectation | undefined,
+        callback: AcceptedCallback
+    ): ICancelableRegistration {
         // a validated connection may already be waiting
         for (let i = 0; i < this.#held.length; i++) {
             const h = this.#held[i];
@@ -341,7 +344,12 @@ export class ClientReverseConnect {
             doDebug && debugLog(`reverse connection from ${serverUri} held (no matching client yet)`);
             timer = setTimeout(() => {
                 timer = undefined;
-                this.#rejectSocket(socket, forget, StatusCodes2.BadTcpServerTooBusy, "no client is waiting for this reverse connection");
+                this.#rejectSocket(
+                    socket,
+                    forget,
+                    StatusCodes2.BadTcpServerTooBusy,
+                    "no client is waiting for this reverse connection"
+                );
             }, this.#matchTimeout);
             timer.unref?.();
             this.#held.push({ accepted, handOff });

package/source/tools/findservers.ts

@@ -5,7 +5,6 @@
 import type { ServerOnNetwork } from "node-opcua-service-discovery";
 import type { ApplicationDescription, EndpointDescription } from "node-opcua-service-endpoints";
 
-
 import { ClientBaseImpl } from "../private/client_base_impl";
 
 export interface FindServerResults {