node-opcua-server 2.164.2 → 2.165.1

package/dist/opcua_server.js

@@ -9,20 +9,18 @@ exports.filterDiagnosticInfo = filterDiagnosticInfo;
 /**
  * @module node-opcua-server
  */
-const crypto_1 = require("crypto");
-const util_1 = require("util");
-const async_1 = __importDefault(require("async"));
+const node_crypto_1 = require("node:crypto");
+const node_util_1 = require("node:util");
 const chalk_1 = __importDefault(require("chalk"));
-const node_opcua_hostname_1 = require("node-opcua-hostname");
-const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_utils_1 = require("node-opcua-utils");
 const node_opcua_address_space_1 = require("node-opcua-address-space");
+const node_opcua_assert_1 = require("node-opcua-assert");
 const node_opcua_certificate_manager_1 = require("node-opcua-certificate-manager");
 const node_opcua_common_1 = require("node-opcua-common");
 const web_1 = require("node-opcua-crypto/web");
 const node_opcua_data_model_1 = require("node-opcua-data-model");
 const node_opcua_data_value_1 = require("node-opcua-data-value");
 const node_opcua_debug_1 = require("node-opcua-debug");
+const node_opcua_hostname_1 = require("node-opcua-hostname");
 const node_opcua_object_registry_1 = require("node-opcua-object-registry");
 const node_opcua_secure_channel_1 = require("node-opcua-secure-channel");
 const node_opcua_service_browse_1 = require("node-opcua-service-browse");
@@ -39,9 +37,9 @@ const node_opcua_service_translate_browse_path_1 = require("node-opcua-service-t
 const node_opcua_service_write_1 = require("node-opcua-service-write");
 const node_opcua_status_code_1 = require("node-opcua-status-code");
 const node_opcua_types_1 = require("node-opcua-types");
+const node_opcua_utils_1 = require("node-opcua-utils");
 const node_opcua_variant_1 = require("node-opcua-variant");
-const node_opcua_variant_2 = require("node-opcua-variant");
-const node_opcua_utils_2 = require("node-opcua-utils");
+const thenify_ex_1 = require("thenify-ex");
 const base_server_1 = require("./base_server");
 const factory_1 = require("./factory");
 const monitored_item_1 = require("./monitored_item");
@@ -55,19 +53,16 @@ const user_manager_ua_1 = require("./user_manager_ua");
 function isSubscriptionIdInvalid(subscriptionId) {
     return subscriptionId < 0 || subscriptionId >= 0xffffffff;
 }
-// tslint:disable-next-line:no-var-requires
-const thenify_ex_1 = require("thenify-ex");
-// tslint:disable-next-line:no-var-requires
 const package_info = require("../package.json");
 const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
 const errorLog = (0, node_opcua_debug_1.make_errorLog)(__filename);
 const warningLog = (0, node_opcua_debug_1.make_warningLog)(__filename);
 const default_maxConnectionsPerEndpoint = 10;
-function g_sendError(channel, message, ResponseClass, statusCode) {
+function g_sendError(channel, message, _ResponseClass, statusCode) {
     const response = new node_opcua_types_1.ServiceFault({
         responseHeader: { serviceResult: statusCode }
     });
-    return channel.send_response("MSG", response, message);
+    channel.send_response("MSG", response, message);
 }
 const default_build_info = {
     manufacturerName: "NodeOPCUA : MIT Licence ( see http://node-opcua.github.io/)",
@@ -90,7 +85,7 @@ function _adjust_session_timeout(sessionTimeout) {
 }
 function channel_has_session(channel, session) {
     if (session.channel === channel) {
-        (0, node_opcua_assert_1.assert)(Object.prototype.hasOwnProperty.call(channel.sessionTokens, session.authenticationToken.toString()));
+        (0, node_opcua_assert_1.assert)(Object.hasOwn(channel.sessionTokens, session.authenticationToken.toString()));
         return true;
     }
     return false;
@@ -102,12 +97,12 @@ function moveSessionToChannel(session, channel) {
     }
     session._detach_channel();
     session._attach_channel(channel);
-    (0, node_opcua_assert_1.assert)(session.channel.channelId === channel.channelId);
+    (0, node_opcua_assert_1.assert)(session.channel?.channelId === channel.channelId);
 }
 async function _attempt_to_close_some_old_unactivated_session(server) {
-    const session = server.engine.getOldestInactiveSession();
+    const session = server.engine?.getOldestInactiveSession();
     if (session) {
-        await server.engine.closeSession(session.authenticationToken, false, "Forcing");
+        await server.engine?.closeSession(session.authenticationToken, false, "Forcing");
     }
 }
 function getRequiredEndpointInfo(endpoint) {
@@ -129,7 +124,7 @@ function getRequiredEndpointInfo(endpoint) {
         userIdentityTokens: endpoint.userIdentityTokens
     });
     // reduce even further by explicitly setting unwanted members to null
-    e.server.applicationName = null;
+    e.server.applicationName = new node_opcua_data_model_1.LocalizedText({ text: "" });
     // xx e.server.applicationType = null as any;
     e.server.gatewayServerUri = null;
     e.server.discoveryProfileUri = null;
@@ -145,9 +140,9 @@ function _serverEndpointsForCreateSessionResponse(server, endpointUrl, serverUri
     // https://reference.opcfoundation.org/v104/Core/docs/Part4/5.6.2/
     // https://reference.opcfoundation.org/v105/Core/docs/Part4/5.6.2/
     return server
-        ._get_endpoints(endpointUrl)
+        .findMatchingEndpoints(endpointUrl)
         .filter((e) => !e.restricted) // remove restricted endpoints
-        .filter((e) => (0, node_opcua_utils_2.matchUri)(e.endpointUrl, endpointUrl))
+        .filter((e) => (0, node_opcua_utils_1.matchUri)(e.endpointUrl, endpointUrl))
         .map(getRequiredEndpointInfo);
 }
 function adjustSecurityPolicy(channel, userTokenPolicy_securityPolicyUri) {
@@ -162,11 +157,17 @@ function adjustSecurityPolicy(channel, userTokenPolicy_securityPolicyUri) {
 }
 function findUserTokenByPolicy(endpoint_description, userTokenType, policyId) {
     (0, node_opcua_assert_1.assert)(endpoint_description instanceof node_opcua_types_1.EndpointDescription);
+    if (!endpoint_description.userIdentityTokens) {
+        return null;
+    }
     const r = endpoint_description.userIdentityTokens.filter((userIdentity) => userIdentity.tokenType === userTokenType && (!policyId || userIdentity.policyId === policyId));
     return r.length === 0 ? null : r[0];
 }
 function findUserTokenPolicy(endpoint_description, userTokenType) {
     (0, node_opcua_assert_1.assert)(endpoint_description instanceof node_opcua_types_1.EndpointDescription);
+    if (!endpoint_description.userIdentityTokens) {
+        return null;
+    }
     const r = endpoint_description.userIdentityTokens.filter((userIdentity) => {
         (0, node_opcua_assert_1.assert)(userIdentity.tokenType !== undefined);
         return userIdentity.tokenType === userTokenType;
@@ -182,6 +183,12 @@ function createAnonymousIdentityToken(endpoint_desc) {
     return new node_opcua_service_session_1.AnonymousIdentityToken({ policyId: userTokenPolicy.policyId });
 }
 function sameIdentityToken(token1, token2) {
+    if (!token1 && !token2) {
+        return true;
+    }
+    if (!token1 || !token2) {
+        return false;
+    }
     if (token1 instanceof node_opcua_service_session_1.UserNameIdentityToken) {
         if (!(token2 instanceof node_opcua_service_session_1.UserNameIdentityToken)) {
             return false;
@@ -299,7 +306,7 @@ function build_scanning_node_function(addressSpace, itemToMonitor) {
         };
     }
 }
-function prepareMonitoredItem(context, addressSpace, monitoredItem) {
+function prepareMonitoredItem(_context, addressSpace, monitoredItem) {
     const itemToMonitor = monitoredItem.itemToMonitor;
     const readNodeFunc = build_scanning_node_function(addressSpace, itemToMonitor);
     monitoredItem.samplingFunc = readNodeFunc;
@@ -374,7 +381,7 @@ function _installRegisterServerManager(self) {
     });
 }
 function validate_applicationUri(channel, request) {
-    const applicationUri = request.clientDescription.applicationUri;
+    const applicationUri = request.clientDescription.applicationUri || "";
     const clientCertificate = request.clientCertificate;
     // if session is insecure there is no need to check certificate information
     if (channel.securityMode === node_opcua_secure_channel_1.MessageSecurityMode.None) {
@@ -384,7 +391,7 @@ function validate_applicationUri(channel, request) {
         return true; // can't check
     }
     const e = (0, web_1.exploreCertificate)(clientCertificate);
-    const uniformResourceIdentifier = e.tbsCertificate.extensions.subjectAltName?.uniformResourceIdentifier ?? null;
+    const uniformResourceIdentifier = e.tbsCertificate.extensions?.subjectAltName?.uniformResourceIdentifier ?? null;
     const applicationUriFromCert = uniformResourceIdentifier && uniformResourceIdentifier.length > 0 ? uniformResourceIdentifier[0] : null;
     /* c8 ignore next */
     if (applicationUriFromCert !== applicationUri) {
@@ -396,7 +403,7 @@ function validate_applicationUri(channel, request) {
 }
 function validate_security_endpoint(server, request, channel) {
     debugLog("validate_security_endpoint = ", request.endpointUrl);
-    let endpoints = server._get_endpoints(request.endpointUrl);
+    let endpoints = server.findMatchingEndpoints(request.endpointUrl);
     // endpointUrl String The network address that the Client used to access the Session Endpoint.
     //             The HostName portion of the URL should be one of the HostNames for the application that are
     //             specified in the Server’s ApplicationInstanceCertificate (see 7.2). The Server shall raise an
@@ -408,22 +415,22 @@ function validate_security_endpoint(server, request, channel) {
     // sometime endpoints have a extra leading "/" that can be ignored
     // don't be too harsh.
     if (endpoints.length === 0 && request.endpointUrl?.endsWith("/")) {
-        endpoints = server._get_endpoints(request.endpointUrl.slice(0, -1));
+        endpoints = server.findMatchingEndpoints(request.endpointUrl.slice(0, -1));
     }
     if (endpoints.length === 0) {
         // we have a UrlMismatch here
-        const ua_server = server.engine.addressSpace.rootFolder.objects.server;
+        const ua_server = server.engine.addressSpace?.rootFolder.objects.server;
         if (!request.endpointUrl?.match(/localhost/i) || OPCUAServer.requestExactEndpointUrl) {
             warningLog("Cannot find suitable endpoints in available endpoints. endpointUri =", request.endpointUrl);
         }
-        ua_server.raiseEvent("AuditUrlMismatchEventType", {
+        ua_server?.raiseEvent("AuditUrlMismatchEventType", {
             endpointUrl: { dataType: node_opcua_variant_1.DataType.String, value: request.endpointUrl }
         });
         if (OPCUAServer.requestExactEndpointUrl) {
             return { errCode: node_opcua_status_code_1.StatusCodes.BadServiceUnsupported };
         }
         else {
-            endpoints = server._get_endpoints(null);
+            endpoints = server.findMatchingEndpoints(null);
         }
     }
     // ignore restricted endpoints
@@ -435,7 +442,7 @@ function validate_security_endpoint(server, request, channel) {
         return { errCode: node_opcua_status_code_1.StatusCodes.BadSecurityModeRejected };
     }
     const endpoints_matching_security_policy = endpoints_matching_security_mode.filter((e) => {
-        return e.securityPolicyUri === channel.securityPolicy;
+        return e.securityPolicyUri === channel?.securityPolicy;
     });
     if (endpoints_matching_security_policy.length === 0) {
         return { errCode: node_opcua_status_code_1.StatusCodes.BadSecurityPolicyRejected };
@@ -443,7 +450,10 @@ function validate_security_endpoint(server, request, channel) {
     if (endpoints_matching_security_policy.length !== 1) {
         debugLog("endpoints_matching_security_policy= ", endpoints_matching_security_policy.length);
     }
-    return { errCode: node_opcua_status_code_1.StatusCodes.Good, endpoint: endpoints_matching_security_policy[0] };
+    return {
+        errCode: node_opcua_status_code_1.StatusCodes.Good,
+        endpoint: endpoints_matching_security_policy[0]
+    };
 }
 function filterDiagnosticInfo(returnDiagnostics, response) {
     if (node_opcua_data_model_1.RESPONSE_DIAGNOSTICS_MASK_ALL & returnDiagnostics) {
@@ -477,6 +487,12 @@ const g_requestExactEndpointUrl = !!process.env.NODEOPCUA_SERVER_REQUEST_EXACT_E
  *
  */
 class OPCUAServer extends base_server_1.OPCUABaseServer {
+    engine;
+    registerServerMethod;
+    discoveryServerEndpointUrl;
+    registerServerManager;
+    capabilitiesForMDNS;
+    userCertificateManager;
     static defaultShutdownTimeout = 100; // 250 ms
     /**
      * if requestExactEndpointUrl is set to true the server will only accept createSession that have a endpointUrl that strictly matches
@@ -575,6 +591,117 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     get isAuditing() {
         return this.engine ? this.engine.isAuditing : false;
     }
+    /**
+     * Set the current server state.
+     *
+     * Updates both the internal state and the
+     * `Server.ServerStatus.State` variable in the
+     * address space so that OPC UA reads reflect the
+     * new state immediately.
+     */
+    setServerState(serverState) {
+        this.engine.setServerState(serverState);
+    }
+    /**
+     * Read the current `ServerState` from the
+     * internal server status.
+     */
+    getServerState() {
+        return this.engine.getServerState();
+    }
+    /**
+     * Set or clear a temporary role-policy override.
+     *
+     * When set, the override's `getUserRoles(username)`
+     * is called **before** the default `userManager`.
+     * Returning a `NodeId[]` overrides the roles;
+     * returning `null` falls through to the default.
+     *
+     * Call with `null` to remove the override and
+     * restore default behavior.
+     */
+    setRolePolicyOverride(override) {
+        this.rolePolicyOverride = override;
+    }
+    /**
+     * Set `ServerConfiguration.InApplicationSetup` in
+     * the address space.
+     *
+     * Indicates whether the server is in its initial
+     * application setup phase (e.g. awaiting GDS
+     * provisioning).
+     */
+    setInApplicationSetup(value) {
+        this.engine.setInApplicationSetup(value);
+    }
+    /**
+     * Read the current value of
+     * `ServerConfiguration.InApplicationSetup`.
+     */
+    getInApplicationSetup() {
+        return this.engine.getInApplicationSetup();
+    }
+    /**
+     * Collect additional hostnames for the self-signed certificate SAN.
+     *
+     * Merges hostnames from `alternateHostname` and parsed
+     * `advertisedEndpoints` URLs so the certificate covers all
+     * configured addresses.
+     *
+     * IP literals (v4/v6) are **excluded** — they are handled by
+     * `getConfiguredIPs()` and placed in the SAN `iPAddress` entries.
+     *
+     * @internal
+     */
+    getConfiguredHostnames() {
+        return this._collectAlternateValues().hostnames;
+    }
+    /**
+     * Collect additional IP addresses for the self-signed certificate SAN.
+     *
+     * Merges IP literals from `alternateHostname` and parsed
+     * `advertisedEndpoints` URLs so the certificate covers all
+     * configured IP addresses.
+     *
+     * @internal
+     */
+    getConfiguredIPs() {
+        return this._collectAlternateValues().ips;
+    }
+    /**
+     * Classify all values from `alternateHostname` and
+     * `advertisedEndpoints` into hostnames vs IP addresses using
+     * `isIPAddress()` (wraps `net.isIP()`).
+     */
+    _collectAlternateValues() {
+        const hostnames = [];
+        const ips = [];
+        // alternateHostname
+        const alt = this.options.alternateHostname;
+        if (alt) {
+            const altArray = Array.isArray(alt) ? alt : [alt];
+            for (const value of altArray) {
+                if ((0, node_opcua_hostname_1.isIPAddress)(value)) {
+                    ips.push(value);
+                }
+                else {
+                    hostnames.push(value);
+                }
+            }
+        }
+        // advertisedEndpoints — normalize to AdvertisedEndpointConfig[]
+        const advList = (0, server_end_point_1.normalizeAdvertisedEndpoints)(this.options.advertisedEndpoints);
+        for (const config of advList) {
+            const { hostname } = (0, server_end_point_1.parseOpcTcpUrl)(config.url);
+            if ((0, node_opcua_hostname_1.isIPAddress)(hostname)) {
+                ips.push(hostname);
+            }
+            else {
+                hostnames.push(hostname);
+            }
+        }
+        return { hostnames, ips };
+    }
     static registry = new node_opcua_object_registry_1.ObjectRegistry();
     static fallbackSessionName = "Client didn't provide a meaningful sessionName ...";
     /**
@@ -658,7 +785,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             // to check => this.serverInfo.applicationName = this.serverInfo.productName || buildInfo.productName;
             // note: applicationUri is handled in a special way
             this.engine = new server_engine_1.ServerEngine({
-                applicationUri: () => this.serverInfo.applicationUri,
+                applicationUri: () => this.serverInfo.applicationUri || "",
                 buildInfo,
                 isAuditing: options.isAuditing,
                 serverCapabilities: options.serverCapabilities,
@@ -691,6 +818,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                     host: options.host,
                     allowAnonymous: options.allowAnonymous,
                     alternateHostname: options.alternateHostname,
+                    advertisedEndpoints: options.advertisedEndpoints,
                     disableDiscovery: options.disableDiscovery,
                     securityModes: options.securityModes,
                     securityPolicies: options.securityPolicies
@@ -728,6 +856,10 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             .then(() => {
             OPCUAServer.registry.register(this);
             this.engine.initialize(this.options, () => {
+                if (!this.engine.addressSpace) {
+                    done(new Error("no addressSpace"));
+                    return;
+                }
                 (0, user_manager_ua_1.bindRoleSet)(this.userManager, this.engine.addressSpace);
                 setImmediate(() => {
                     this.emit("post_initialize");
@@ -740,34 +872,33 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         });
     }
     start(...args) {
-        const done = args[0];
-        const tasks = [];
-        tasks.push((0, util_1.callbackify)(node_opcua_hostname_1.extractFullyQualifiedDomainName));
+        const callback = args[0];
+        if (callback) {
+            return super.start(callback);
+        }
+        return super.start();
+    }
+    /**
+     * Initiate the server by starting all its endpoints
+     * @private
+     */
+    async startAsync() {
+        await (0, node_opcua_hostname_1.extractFullyQualifiedDomainName)();
         if (!this.initialized) {
-            tasks.push((callback) => {
-                this.initialize(callback);
-            });
+            await this.initialize();
         }
-        tasks.push((callback) => {
-            super.start((err) => {
-                if (err) {
-                    this.shutdown((/*err2*/ err2) => {
-                        callback(err);
-                    });
-                }
-                else {
-                    // we start the registration process asynchronously
-                    // as we want to make server immediately available
-                    this.registerServerManager.start().then(() => {
-                        /* empty */
-                    }).catch((err) => {
-                        /* empty */
-                    });
-                    setImmediate(callback);
-                }
-            });
+        try {
+            await super.startAsync();
+        }
+        catch (err) {
+            await this.shutdown();
+            throw err;
+        }
+        // we start the registration process asynchronously
+        // as we want to make server immediately available
+        this.registerServerManager?.start().catch(() => {
+            /* empty */
         });
-        async_1.default.series(tasks, done);
     }
     shutdown(...args) {
         const timeout = args.length === 1 ? OPCUAServer.defaultShutdownTimeout : args[0];
@@ -788,21 +919,27 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         this.engine.setServerState(node_opcua_common_1.ServerState.Shutdown);
         const shutdownTime = new Date(Date.now() + timeout);
         this.engine.setShutdownTime(shutdownTime);
-        debugLog("OPCUAServer is now un-registering itself from  the discovery server " + this.buildInfo);
-        this.registerServerManager.stop()
+        debugLog("OPCUAServer is now un-registering itself from  the discovery server ", this.buildInfo);
+        if (!this.registerServerManager) {
+            callback(new Error("invalid register server manager"));
+            return;
+        }
+        this.registerServerManager
+            .stop()
             .then(() => {
             debugLog("OPCUAServer unregistered from discovery server successfully");
         })
             .catch((err) => {
             debugLog("OPCUAServer unregistered from discovery server with err: ", err.message);
-        }).finally(() => {
+        })
+            .finally(() => {
             setTimeout(async () => {
                 await this.engine.shutdown();
                 debugLog("OPCUAServer#shutdown: started");
                 base_server_1.OPCUABaseServer.prototype.shutdown.call(this, (err1) => {
                     debugLog("OPCUAServer#shutdown: completed");
                     this.dispose();
-                    callback(err1);
+                    callback(err1 || undefined);
                 });
             }, timeout);
         });
@@ -839,14 +976,14 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         if (typeof eventType === "string") {
             eventTypeNode = this.engine.addressSpace.findEventType(eventType);
             if (eventTypeNode) {
-                return server.raiseEvent(eventTypeNode, options);
+                server.raiseEvent(eventTypeNode, options);
             }
             else {
                 console.warn(" cannot find event type ", eventType);
             }
         }
         else {
-            return server.raiseEvent(eventTypeNode, options);
+            server.raiseEvent(eventTypeNode, options);
         }
     }
     /**
@@ -890,30 +1027,34 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         const result = (0, node_opcua_secure_channel_1.verifySignature)(serverCertificate, session.nonce, clientSignature, clientCertificate, securityPolicy);
         return result;
     }
-    isValidUserNameIdentityToken(channel, session, userTokenPolicy, userIdentityToken, userTokenSignature, callback) {
+    isValidUserNameIdentityToken(channel, _session, userTokenPolicy, userIdentityToken, _userTokenSignature, callback) {
         (0, node_opcua_assert_1.assert)(userIdentityToken instanceof node_opcua_service_session_1.UserNameIdentityToken);
         const securityPolicy = adjustSecurityPolicy(channel, userTokenPolicy.securityPolicyUri);
         if (securityPolicy === node_opcua_secure_channel_1.SecurityPolicy.None) {
-            return callback(null, node_opcua_status_code_1.StatusCodes.Good);
+            callback(null, node_opcua_status_code_1.StatusCodes.Good);
+            return;
         }
         const cryptoFactory = (0, node_opcua_secure_channel_1.getCryptoFactory)(securityPolicy);
         /* c8 ignore next */
         if (!cryptoFactory) {
-            return callback(null, node_opcua_status_code_1.StatusCodes.BadSecurityPolicyRejected);
+            callback(null, node_opcua_status_code_1.StatusCodes.BadSecurityPolicyRejected);
+            return;
         }
         /* c8 ignore next */
         if (userIdentityToken.encryptionAlgorithm !== cryptoFactory.asymmetricEncryptionAlgorithm) {
             errorLog("invalid encryptionAlgorithm");
             errorLog("userTokenPolicy", userTokenPolicy.toString());
             errorLog("userTokenPolicy", userIdentityToken.toString());
-            return callback(null, node_opcua_status_code_1.StatusCodes.BadIdentityTokenInvalid);
+            callback(null, node_opcua_status_code_1.StatusCodes.BadIdentityTokenInvalid);
+            return;
         }
         const userName = userIdentityToken.userName;
         const password = userIdentityToken.password;
         if (!userName || !password) {
-            return callback(null, node_opcua_status_code_1.StatusCodes.BadIdentityTokenInvalid);
+            callback(null, node_opcua_status_code_1.StatusCodes.BadIdentityTokenInvalid);
+            return;
         }
-        return callback(null, node_opcua_status_code_1.StatusCodes.Good);
+        callback(null, node_opcua_status_code_1.StatusCodes.Good);
     }
     isValidX509IdentityToken(channel, session, userTokenPolicy, userIdentityToken, userTokenSignature, callback) {
         (0, node_opcua_assert_1.assert)(userIdentityToken instanceof node_opcua_service_session_1.X509IdentityToken);
@@ -922,28 +1063,33 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         const cryptoFactory = (0, node_opcua_secure_channel_1.getCryptoFactory)(securityPolicy);
         /* c8 ignore next */
         if (!cryptoFactory) {
-            return callback(null, node_opcua_status_code_1.StatusCodes.BadSecurityPolicyRejected);
+            callback(null, node_opcua_status_code_1.StatusCodes.BadSecurityPolicyRejected);
+            return;
         }
         if (!userTokenSignature || !userTokenSignature.signature) {
             this.raiseEvent("AuditCreateSessionEventType", {});
-            return callback(null, node_opcua_status_code_1.StatusCodes.BadUserSignatureInvalid);
+            callback(null, node_opcua_status_code_1.StatusCodes.BadUserSignatureInvalid);
+            return;
         }
         if (userIdentityToken.policyId !== userTokenPolicy.policyId) {
             errorLog("invalid encryptionAlgorithm");
             errorLog("userTokenPolicy", userTokenPolicy.toString());
             errorLog("userTokenPolicy", userIdentityToken.toString());
-            return callback(null, node_opcua_status_code_1.StatusCodes.BadSecurityPolicyRejected);
+            callback(null, node_opcua_status_code_1.StatusCodes.BadSecurityPolicyRejected);
+            return;
         }
         const certificate = userIdentityToken.certificateData; /* as Certificate*/
         const nonce = session.nonce;
+        if (!nonce || nonce.length === 0) {
+            callback(null, node_opcua_status_code_1.StatusCodes.BadNonceInvalid);
+            return;
+        }
         const serverCertificate = this.getCertificate();
-        (0, node_opcua_assert_1.assert)(serverCertificate instanceof Buffer);
-        (0, node_opcua_assert_1.assert)(certificate instanceof Buffer, "expecting certificate to be a Buffer");
-        (0, node_opcua_assert_1.assert)(nonce instanceof Buffer, "expecting nonce to be a Buffer");
         (0, node_opcua_assert_1.assert)(userTokenSignature.signature instanceof Buffer, "expecting userTokenSignature to be a Buffer");
         // verify proof of possession by checking certificate signature & server nonce correctness
         if (!(0, node_opcua_secure_channel_1.verifySignature)(serverCertificate, nonce, userTokenSignature, certificate, securityPolicy)) {
-            return callback(null, node_opcua_status_code_1.StatusCodes.BadUserSignatureInvalid);
+            callback(null, node_opcua_status_code_1.StatusCodes.BadUserSignatureInvalid);
+            return;
         }
         // verify if certificate is Valid
         this.userCertificateManager.checkCertificate(certificate, (err, certificateStatus) => {
@@ -957,31 +1103,55 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                         break;
                     case node_opcua_status_code_1.StatusCodes.BadCertificateUntrusted:
                         this.raiseEvent("AuditCertificateUntrustedEventType", {
-                            certificate: { dataType: node_opcua_variant_1.DataType.ByteString, value: certificate },
-                            sourceName: { dataType: node_opcua_variant_1.DataType.String, value: "Security/Certificate" }
+                            certificate: {
+                                dataType: node_opcua_variant_1.DataType.ByteString,
+                                value: certificate
+                            },
+                            sourceName: {
+                                dataType: node_opcua_variant_1.DataType.String,
+                                value: "Security/Certificate"
+                            }
                         });
                         break;
                     case node_opcua_status_code_1.StatusCodes.BadCertificateTimeInvalid:
                     case node_opcua_status_code_1.StatusCodes.BadCertificateIssuerTimeInvalid:
                         this.raiseEvent("AuditCertificateExpiredEventType", {
-                            certificate: { dataType: node_opcua_variant_1.DataType.ByteString, value: certificate },
-                            sourceName: { dataType: node_opcua_variant_1.DataType.String, value: "Security/Certificate" }
+                            certificate: {
+                                dataType: node_opcua_variant_1.DataType.ByteString,
+                                value: certificate
+                            },
+                            sourceName: {
+                                dataType: node_opcua_variant_1.DataType.String,
+                                value: "Security/Certificate"
+                            }
                         });
                         break;
                     case node_opcua_status_code_1.StatusCodes.BadCertificateRevoked:
                     case node_opcua_status_code_1.StatusCodes.BadCertificateRevocationUnknown:
                     case node_opcua_status_code_1.StatusCodes.BadCertificateIssuerRevocationUnknown:
                         this.raiseEvent("AuditCertificateRevokedEventType", {
-                            certificate: { dataType: node_opcua_variant_1.DataType.ByteString, value: certificate },
-                            sourceName: { dataType: node_opcua_variant_1.DataType.String, value: "Security/Certificate" }
+                            certificate: {
+                                dataType: node_opcua_variant_1.DataType.ByteString,
+                                value: certificate
+                            },
+                            sourceName: {
+                                dataType: node_opcua_variant_1.DataType.String,
+                                value: "Security/Certificate"
+                            }
                         });
                         break;
                     case node_opcua_status_code_1.StatusCodes.BadCertificateIssuerUseNotAllowed:
                     case node_opcua_status_code_1.StatusCodes.BadCertificateUseNotAllowed:
                     case node_opcua_status_code_1.StatusCodes.BadSecurityChecksFailed:
                         this.raiseEvent("AuditCertificateMismatchEventType", {
-                            certificate: { dataType: node_opcua_variant_1.DataType.ByteString, value: certificate },
-                            sourceName: { dataType: node_opcua_variant_1.DataType.String, value: "Security/Certificate" }
+                            certificate: {
+                                dataType: node_opcua_variant_1.DataType.ByteString,
+                                value: certificate
+                            },
+                            sourceName: {
+                                dataType: node_opcua_variant_1.DataType.String,
+                                value: "Security/Certificate"
+                            }
                         });
                         break;
                 }
@@ -1020,6 +1190,10 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         // assert(this.isValidUserNameIdentityToken(channel, session, userTokenPolicy, userIdentityToken));
         const securityPolicy = adjustSecurityPolicy(channel, userTokenPolicy.securityPolicyUri);
         const userName = userIdentityToken.userName;
+        if (!userName) {
+            callback(new Error(" expecting a no null username"));
+            return;
+        }
         let password = userIdentityToken.password;
         // decrypt password if necessary
         if (securityPolicy === node_opcua_secure_channel_1.SecurityPolicy.None) {
@@ -1029,16 +1203,20 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         else {
             const serverPrivateKey = this.getPrivateKey();
             const serverNonce = session.nonce;
-            (0, node_opcua_assert_1.assert)(serverNonce instanceof Buffer);
+            if (!serverNonce) {
+                callback(new Error(" expecting a no null nonce"));
+                return;
+            }
             const cryptoFactory = (0, node_opcua_secure_channel_1.getCryptoFactory)(securityPolicy);
             /* c8 ignore next */
             if (!cryptoFactory) {
-                return callback(new Error(" Unsupported security Policy"));
+                callback(new Error(" Unsupported security Policy"));
+                return;
             }
             const buff = cryptoFactory.asymmetricDecrypt(password, serverPrivateKey);
             // server certificate may be invalid and asymmetricDecrypt may fail
             if (!buff || buff.length < 4) {
-                async_1.default.setImmediate(() => callback(null, false));
+                setImmediate(() => callback(null, false));
                 return;
             }
             const length = buff.readUInt32LE(0) - serverNonce.length;
@@ -1062,16 +1240,19 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         const userTokenPolicy = findUserTokenByPolicy(endpointDescription, userTokenType, userIdentityToken.policyId);
         if (!userTokenPolicy) {
             // cannot find token with this policyId
-            return callback(null, node_opcua_status_code_1.StatusCodes.BadIdentityTokenInvalid);
+            callback(null, node_opcua_status_code_1.StatusCodes.BadIdentityTokenInvalid);
+            return;
         }
         //
         if (userIdentityToken instanceof node_opcua_service_session_1.UserNameIdentityToken) {
-            return this.isValidUserNameIdentityToken(channel, session, userTokenPolicy, userIdentityToken, userTokenSignature, callback);
+            this.isValidUserNameIdentityToken(channel, session, userTokenPolicy, userIdentityToken, userTokenSignature, callback);
+            return;
         }
         if (userIdentityToken instanceof node_opcua_service_session_1.X509IdentityToken) {
-            return this.isValidX509IdentityToken(channel, session, userTokenPolicy, userIdentityToken, userTokenSignature, callback);
+            this.isValidX509IdentityToken(channel, session, userTokenPolicy, userIdentityToken, userTokenSignature, callback);
+            return;
         }
-        return callback(null, node_opcua_status_code_1.StatusCodes.Good);
+        callback(null, node_opcua_status_code_1.StatusCodes.Good);
     }
     /**
      *
@@ -1089,16 +1270,18 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         const userTokenPolicy = findUserTokenByPolicy(session.getEndpointDescription(), userTokenType, userIdentityToken.policyId);
         /** c8 ignore next */
         if (!userTokenPolicy) {
-            return callback(null, false);
+            callback(null, false);
+            return;
         }
         // find if a userToken exists
         if (userIdentityToken instanceof node_opcua_service_session_1.UserNameIdentityToken) {
-            return this.userNameIdentityTokenAuthenticateUser(channel, session, userTokenPolicy, userIdentityToken, callback);
+            this.userNameIdentityTokenAuthenticateUser(channel, session, userTokenPolicy, userIdentityToken, callback);
+            return;
         }
-        async_1.default.setImmediate(callback.bind(null, null, true));
+        setImmediate(callback.bind(null, null, true));
     }
     makeServerNonce() {
-        return (0, crypto_1.randomBytes)(32);
+        return (0, node_crypto_1.randomBytes)(32);
     }
     // session services
     // eslint-disable-next-line max-statements
@@ -1146,12 +1329,12 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         // its application instance Certificate in the response.
         if (!request.clientNonce || request.clientNonce.length < 32) {
             if (channel.securityMode !== node_opcua_secure_channel_1.MessageSecurityMode.None) {
-                errorLog(chalk_1.default.red("SERVER with secure connection: Missing or invalid client Nonce "), request.clientNonce && request.clientNonce.toString("hex"));
+                errorLog(chalk_1.default.red("SERVER with secure connection: Missing or invalid client Nonce "), request.clientNonce?.toString("hex"));
                 return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadNonceInvalid);
             }
         }
         if ((0, node_opcua_secure_channel_1.nonceAlreadyBeenUsed)(request.clientNonce)) {
-            errorLog(chalk_1.default.red("SERVER with secure connection: Nonce has already been used"), request.clientNonce && request.clientNonce.toString("hex"));
+            errorLog(chalk_1.default.red("SERVER with secure connection: Nonce has already been used"), request.clientNonce?.toString("hex"));
             return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadNonceInvalid);
         }
         // check application spoofing
@@ -1193,7 +1376,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         const serverCertificateChain = this.getCertificateChain();
         const hasEncryption = true;
         // If the securityPolicyUri is None and none of the UserTokenPolicies requires encryption
-        if (session.channel.securityMode === node_opcua_secure_channel_1.MessageSecurityMode.None) {
+        if (session.channel?.securityMode === node_opcua_secure_channel_1.MessageSecurityMode.None) {
             // ToDo: Check that none of our insecure endpoint has a a UserTokenPolicy that require encryption
             // and set hasEncryption = false under this condition
         }
@@ -1224,7 +1407,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             // securityPolicyUri, userIdentityTokens, transportProfileUri and securityLevel with all
             // other parameters set to null. Only the recommended parameters shall be verified by
             // the client.
-            serverEndpoints: _serverEndpointsForCreateSessionResponse(this, session.endpoint.endpointUrl, request.serverUri),
+            serverEndpoints: _serverEndpointsForCreateSessionResponse(this, session.endpoint?.endpointUrl || "", request.serverUri),
             // This parameter is deprecated and the array shall be empty.
             serverSoftwareCertificates: null,
             // This is a signature generated with the private key associated with the
@@ -1245,7 +1428,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             (0, node_opcua_assert_1.assert)(typeof reason === "string");
             if (this.isAuditing) {
                 (0, node_opcua_assert_1.assert)(reason === "Timeout" || reason === "Terminated" || reason === "CloseSession" || reason === "Forcing");
-                const sourceName = "Session/" + reason;
+                const sourceName = `Session/${reason}`;
                 this.raiseEvent("AuditSessionEventType", {
                     /* part 5 -  6.4.3 AuditEventType */
                     actionTimeStamp: { dataType: "DateTime", value: new Date() },
@@ -1283,15 +1466,24 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 // identifier in all AuditEvents related to the Session Service Set (AuditCreateSessionEventType,
                 // AuditActivateSessionEventType and their subtypes) and the SecureChannel Service Set
                 // (AuditChannelEventType and its subtypes
-                secureChannelId: { dataType: "String", value: session.channel.channelId.toString() },
+                secureChannelId: {
+                    dataType: "String",
+                    value: session.channel?.channelId?.toString() ?? ""
+                },
                 // Duration
-                revisedSessionTimeout: { dataType: "Duration", value: session.sessionTimeout },
+                revisedSessionTimeout: {
+                    dataType: "Duration",
+                    value: session.sessionTimeout
+                },
                 // clientCertificate
-                clientCertificate: { dataType: "ByteString", value: session.channel.clientCertificate },
+                clientCertificate: {
+                    dataType: "ByteString",
+                    value: session.channel?.clientCertificate ?? null
+                },
                 // clientCertificateThumbprint
                 clientCertificateThumbprint: {
                     dataType: "String",
-                    value: thumbprint(session.channel.clientCertificate)
+                    value: thumbprint(session.channel?.clientCertificate)
                 }
             });
         }
@@ -1329,16 +1521,18 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 server.engine.incrementRejectedSessionCount();
                 server.engine.incrementSecurityRejectedSessionCount();
             }
-            const response1 = new node_opcua_service_session_1.ActivateSessionResponse({ responseHeader: { serviceResult: statusCode } });
+            const response1 = new node_opcua_service_session_1.ActivateSessionResponse({
+                responseHeader: { serviceResult: statusCode }
+            });
             channel.send_response("MSG", response1, message);
         }
-        let response;
         /* c8 ignore next */
         if (!session) {
             // this may happen when the server has been restarted and a client tries to reconnect, thinking
             // that the previous session may still be active
             debugLog(chalk_1.default.yellow.bold(" Bad Session in  _on_ActivateSessionRequest"), authenticationToken.toString());
-            return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadSessionIdInvalid);
+            rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadSessionIdInvalid);
+            return;
         }
         // tslint:disable-next-line: no-unused-expression
         session.keepAlive ? session.keepAlive() : void 0;
@@ -1350,8 +1544,9 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             if (!channel_has_session(channel, session)) {
                 // it looks like session activation is being using a channel that is not the
                 // one that have been used to create the session
-                errorLog(" channel.sessionTokens === " + Object.keys(channel.sessionTokens).join(" "));
-                return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadSessionNotActivated);
+                errorLog(` channel.sessionTokens === ${Object.keys(channel.sessionTokens).join(" ")}`);
+                rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadSessionNotActivated);
+                return;
             }
         }
         // OpcUA 1.02 part 3 $5.6.3.1 ActiveSession Set page 29
@@ -1359,39 +1554,49 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         // case then  the  Server  shall verify that the  Certificate  the  Client  used to create the new
         // SecureChannel  is the same as the  Certificate  used to create the original  SecureChannel.
         if (session.status === "active") {
-            if (session.channel.channelId !== channel.channelId) {
-                warningLog(" Session ", session.sessionName, " is being transferred from channel", chalk_1.default.cyan(session.channel.channelId.toString()), " to channel ", chalk_1.default.cyan(channel.channelId.toString()));
+            if (session.channel?.channelId !== channel.channelId) {
+                warningLog(" Session ", session.sessionName, " is being transferred from channel", chalk_1.default.cyan(session.channel?.channelId?.toString()), " to channel ", chalk_1.default.cyan(channel.channelId?.toString()));
                 // session is being reassigned to a new Channel,
                 // we shall verify that the certificate used to create the Session is the same as the current
                 // channel certificate.
-                const old_channel_cert_thumbprint = thumbprint(session.channel.clientCertificate);
+                const old_channel_cert_thumbprint = thumbprint(session.channel?.clientCertificate);
                 const new_channel_cert_thumbprint = thumbprint(channel.clientCertificate);
                 if (old_channel_cert_thumbprint !== new_channel_cert_thumbprint) {
-                    return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadNoValidCertificates); // not sure about this code !
+                    rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadNoValidCertificates); // not sure about this code !
+                    return;
                 }
                 // ... In addition the Server shall verify that the  Client  supplied a  UserIdentityToken  that is
                 // identical to the token currently associated with the  Session reassign session to new channel.
                 if (!sameIdentityToken(session.userIdentityToken, request.userIdentityToken)) {
-                    return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadIdentityChangeNotSupported); // not sure about this code !
+                    rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadIdentityChangeNotSupported); // not sure about this code !
+                    return;
                 }
             }
         }
         else if (session.status === "screwed") {
             // session has been used before being activated => this should be detected and session should be dismissed.
-            return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadSessionClosed);
+            rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadSessionClosed);
+            return;
         }
         else if (session.status === "closed") {
             warningLog(chalk_1.default.yellow.bold(" Bad Session Closed in  _on_ActivateSessionRequest"), authenticationToken.toString());
-            return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadSessionClosed);
+            rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadSessionClosed);
+            return;
         }
         // verify clientSignature provided by the client
         if (!this.verifyClientSignature(session, channel, request.clientSignature)) {
-            return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadApplicationSignatureInvalid);
+            rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadApplicationSignatureInvalid);
+            return;
+        }
+        const endpoint = session.endpoint;
+        if (!endpoint) {
+            rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadSessionIdInvalid);
+            return;
         }
         // userIdentityToken may be missing , assume anonymous access then
-        request.userIdentityToken = request.userIdentityToken || createAnonymousIdentityToken(session.endpoint);
+        request.userIdentityToken = request.userIdentityToken || createAnonymousIdentityToken(endpoint);
         // check request.userIdentityToken is correct ( expected type and correctly formed)
-        this.isValidUserIdentityToken(channel, session, request.userIdentityToken, request.userTokenSignature, session.endpoint, (err, statusCode) => {
+        this.isValidUserIdentityToken(channel, session, request.userIdentityToken, request.userTokenSignature, endpoint, (_err, statusCode) => {
             if (!statusCode || statusCode.isNotGood()) {
                 /* c8 ignore next */
                 if (!(statusCode && statusCode instanceof node_opcua_status_code_1.StatusCode)) {
@@ -1418,7 +1623,9 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                     // serverNonce each time the ActivateSession Service is called.
                     session.nonce = this.makeServerNonce();
                     session.status = "active";
-                    response = new node_opcua_service_session_1.ActivateSessionResponse({ serverNonce: session.nonce });
+                    const response = new node_opcua_service_session_1.ActivateSessionResponse({
+                        serverNonce: session.nonce
+                    });
                     channel.send_response("MSG", response, message);
                     // send OPCUA Event Notification
                     // see part 5 : 6.4.3 AuditEventType
@@ -1451,7 +1658,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 // ActivateSession completes the session transfer are expected
                 // transient occurrences, not errors worth logging.
                 if (request.constructor.name !== "PublishRequest") {
-                    errorLog(chalk_1.default.red.bgWhite("ERROR: channel.channelId !== session.channelId  on processing request " + request.constructor.name), channel.channelId, session.channelId);
+                    errorLog(chalk_1.default.red.bgWhite(`ERROR: channel.channelId !== session.channelId  on processing request ${request.constructor.name}`), channel.channelId, session.channelId);
                 }
             }
             message.session_statusCode = node_opcua_status_code_1.StatusCodes.BadSecureChannelIdInvalid;
@@ -1493,7 +1700,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             catch (err) {
                 warningLog(err);
                 // c8 ignore next
-                if (util_1.types.isNativeError(err)) {
+                if (node_util_1.types.isNativeError(err)) {
                     // c8 ignore next
                     errorLog("Internal error in issuing response\nplease contact support@sterfive.com", message.request.toString(), "\n", response1.toString());
                 }
@@ -1507,12 +1714,14 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             }
             return g_sendError(channel, message, ResponseClass, statusCode);
         }
-        let response;
         /* c8 ignore next */
         if (!message.session || message.session_statusCode !== node_opcua_status_code_1.StatusCodes.Good) {
-            const errMessage = "=>" + message.session_statusCode?.toString();
-            response = new node_opcua_types_1.ServiceFault({ responseHeader: { serviceResult: message.session_statusCode } });
-            debugLog(chalk_1.default.red.bold(errMessage), chalk_1.default.yellow(message.session_statusCode.toString()), response.constructor.name);
+            const sessionStatusCode = message.session_statusCode ?? node_opcua_status_code_1.StatusCodes.BadInternalError;
+            const errMessage = `=>${sessionStatusCode.toString()}`;
+            const response = new node_opcua_types_1.ServiceFault({
+                responseHeader: { serviceResult: sessionStatusCode }
+            });
+            debugLog(chalk_1.default.red.bold(errMessage), chalk_1.default.yellow(sessionStatusCode.toString()), response.constructor.name);
             return sendResponse(response);
         }
         (0, node_opcua_assert_1.assert)(message.session_statusCode.isGood());
@@ -1550,7 +1759,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     async _apply_on_Subscription(ResponseClass, message, channel, actionToPerform) {
         (0, node_opcua_assert_1.assert)(typeof actionToPerform === "function");
         const request = message.request;
-        (0, node_opcua_assert_1.assert)(Object.prototype.hasOwnProperty.call(request, "subscriptionId"));
+        (0, node_opcua_assert_1.assert)(Object.hasOwn(request, "subscriptionId"));
         this._apply_on_SessionObject(ResponseClass, message, channel, async (session, sendResponse, sendError) => {
             const subscription = session.getSubscription(request.subscriptionId);
             if (!subscription) {
@@ -1563,7 +1772,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     _apply_on_SubscriptionIds(ResponseClass, message, channel, actionToPerform) {
         (0, node_opcua_assert_1.assert)(typeof actionToPerform === "function");
         const request = message.request;
-        (0, node_opcua_assert_1.assert)(Object.prototype.hasOwnProperty.call(request, "subscriptionIds"));
+        (0, node_opcua_assert_1.assert)(Object.hasOwn(request, "subscriptionIds"));
         this._apply_on_SessionObject(ResponseClass, message, channel, async (session, sendResponse, sendError) => {
             const subscriptionIds = request.subscriptionIds;
             if (!request.subscriptionIds || request.subscriptionIds.length === 0) {
@@ -1605,7 +1814,10 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             if (session) {
                 const subscriptions = session.publishEngine.subscriptions;
                 for (const subscription of subscriptions) {
-                    await subscription.applyOnMonitoredItem(this.options.onDeleteMonitoredItem.bind(null, subscription));
+                    const onDeleteFn = this.options.onDeleteMonitoredItem;
+                    await subscription.applyOnMonitoredItem(async (monitoredItem) => {
+                        await onDeleteFn(subscription, monitoredItem);
+                    });
                 }
             }
         }
@@ -1619,7 +1831,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     _on_CloseSessionRequest(message, channel) {
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_session_1.CloseSessionRequest);
-        let response;
         message.session_statusCode = node_opcua_status_code_1.StatusCodes.Good;
         function sendError(statusCode) {
             return g_sendError(channel, message, node_opcua_service_session_1.CloseSessionResponse, statusCode);
@@ -1632,20 +1843,21 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         // });
         const session = message.session;
         if (!session) {
-            return sendError(node_opcua_status_code_1.StatusCodes.BadSessionIdInvalid);
+            sendError(node_opcua_status_code_1.StatusCodes.BadSessionIdInvalid);
+            return;
         }
         // session has been created but not activated !
-        const wasNotActivated = session.status === "new";
+        const _wasNotActivated = session.status === "new";
         (async () => {
             try {
                 await this._closeSession(request.requestHeader.authenticationToken, request.deleteSubscriptions, "CloseSession");
                 // if (false && wasNotActivated) {
                 //  return sendError(StatusCodes.BadSessionNotActivated);
                 // }
-                response = new node_opcua_service_session_1.CloseSessionResponse({});
+                const response = new node_opcua_service_session_1.CloseSessionResponse({});
                 sendResponse(response);
             }
-            catch (err) {
+            catch (_err) {
                 sendError(node_opcua_status_code_1.StatusCodes.BadInternalError);
             }
         })();
@@ -1664,7 +1876,11 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             let response;
             // test view
             if (request.view && !request.view.viewId.isEmpty()) {
-                let theView = this.engine.addressSpace.findNode(request.view.viewId);
+                const addressSpace = this.engine.addressSpace;
+                if (!addressSpace) {
+                    return sendError(node_opcua_status_code_1.StatusCodes.BadInternalError);
+                }
+                let theView = addressSpace.findNode(request.view.viewId);
                 if (theView && theView.nodeClass !== node_opcua_data_model_1.NodeClass.View) {
                     // Error: theView is not a View
                     diagnostic.localizedText = { text: "Expecting a view here" };
@@ -1686,9 +1902,9 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             const requestedMaxReferencesPerNode = Math.min(9876, request.requestedMaxReferencesPerNode);
             (0, node_opcua_assert_1.assert)(request.nodesToBrowse[0].schema.name === "BrowseDescription");
             const context = session.sessionContext;
-            const browseAll = (nodesToBrowse, callack) => {
-                const f = (0, util_1.callbackify)(this.engine.browseWithAutomaticExpansion).bind(this.engine);
-                f(request.nodesToBrowse, context, callack);
+            const browseAll = (_nodesToBrowse, callack) => {
+                const f = (0, node_util_1.callbackify)(this.engine.browseWithAutomaticExpansion).bind(this.engine);
+                f(request.nodesToBrowse ?? [], context, callack);
             };
             // handle continuation point and requestedMaxReferencesPerNode
             const maxBrowseContinuationPoints = this.engine.serverCapabilities.maxBrowseContinuationPoints;
@@ -1698,7 +1914,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 continuationPointManager: session.continuationPointManager,
                 requestedMaxReferencesPerNode,
                 maxBrowseContinuationPoints
-            }, request.nodesToBrowse, (err, results) => {
+            }, request.nodesToBrowse, (_err, results) => {
                 if (!results) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadInternalError);
                 }
@@ -1763,17 +1979,17 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 nodeToRead.nodeId = session.resolveRegisteredNode(nodeToRead.nodeId);
             }
             // ask for a refresh of asynchronous variables
-            this.engine.refreshValues(request.nodesToRead, request.maxAge, (err) => {
+            this.engine.refreshValues(request.nodesToRead, request.maxAge, (_err) => {
                 this.engine.read(context, request).then((results) => {
                     (0, node_opcua_assert_1.assert)(results[0].schema.name === "DataValue");
-                    (0, node_opcua_assert_1.assert)(results.length === request.nodesToRead.length);
+                    (0, node_opcua_assert_1.assert)(results.length === request.nodesToRead?.length);
                     const response = new node_opcua_service_read_1.ReadResponse({
                         diagnosticInfos: undefined,
                         results: undefined
                     });
                     // set it here for performance
                     response.results = results;
-                    (0, node_opcua_assert_1.assert)(response.diagnosticInfos.length === 0);
+                    (0, node_opcua_assert_1.assert)(response.diagnosticInfos?.length === 0);
                     sendResponse(response);
                 });
             });
@@ -1784,7 +2000,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_history_1.HistoryReadRequest);
         this._apply_on_SessionObject(node_opcua_service_history_1.HistoryReadResponse, message, channel, (session, sendResponse, sendError) => {
-            let response;
             const timestampsToReturn = request.timestampsToReturn;
             if (timestampsToReturn === node_opcua_service_read_1.TimestampsToReturn.Invalid) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadTimestampsToReturnInvalid);
@@ -1819,15 +2034,15 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                     .historyRead(context, request)
                     .then((results) => {
                     (0, node_opcua_assert_1.assert)(results[0].schema.name === "HistoryReadResult");
-                    (0, node_opcua_assert_1.assert)(results.length === request.nodesToRead.length);
-                    response = new node_opcua_service_history_1.HistoryReadResponse({
+                    (0, node_opcua_assert_1.assert)(results.length === request.nodesToRead?.length);
+                    const response = new node_opcua_service_history_1.HistoryReadResponse({
                         diagnosticInfos: undefined,
                         results
                     });
-                    (0, node_opcua_assert_1.assert)(response.diagnosticInfos.length === 0);
+                    (0, node_opcua_assert_1.assert)(response.diagnosticInfos?.length === 0);
                     sendResponse(response);
                 })
-                    .catch((err) => {
+                    .catch((_err) => {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadHistoryOperationInvalid);
                 });
             });
@@ -1852,7 +2067,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_write_1.WriteRequest);
         (0, node_opcua_assert_1.assert)(!request.nodesToWrite || Array.isArray(request.nodesToWrite));
         this._apply_on_SessionObject(node_opcua_service_write_1.WriteResponse, message, channel, (session, sendResponse, sendError) => {
-            let response;
             if (!request.nodesToWrite || request.nodesToWrite.length === 0) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadNothingToDo);
             }
@@ -1870,8 +2084,8 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             this.engine
                 .write(context, request.nodesToWrite)
                 .then((results) => {
-                (0, node_opcua_assert_1.assert)(results.length === request.nodesToWrite.length);
-                response = new node_opcua_service_write_1.WriteResponse({
+                (0, node_opcua_assert_1.assert)(results?.length === request.nodesToWrite?.length);
+                const response = new node_opcua_service_write_1.WriteResponse({
                     diagnosticInfos: undefined,
                     results
                 });
@@ -1887,6 +2101,10 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     _on_CreateSubscriptionRequest(message, channel) {
         const engine = this.engine;
         const addressSpace = engine.addressSpace;
+        if (!addressSpace) {
+            g_sendError(channel, message, node_opcua_service_subscription_1.CreateSubscriptionResponse, node_opcua_status_code_1.StatusCodes.BadSessionClosed);
+            return;
+        }
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.CreateSubscriptionRequest);
         this._apply_on_SessionObject(node_opcua_service_subscription_1.CreateSubscriptionResponse, message, channel, (session, sendResponse, sendError) => {
@@ -1947,9 +2165,13 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     _on_CreateMonitoredItemsRequest(message, channel) {
         const engine = this.engine;
         const addressSpace = engine.addressSpace;
+        if (!addressSpace) {
+            g_sendError(channel, message, node_opcua_service_subscription_1.CreateMonitoredItemsResponse, node_opcua_status_code_1.StatusCodes.BadSessionClosed);
+            return;
+        }
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.CreateMonitoredItemsRequest);
-        this._apply_on_Subscription(node_opcua_service_subscription_1.CreateMonitoredItemsResponse, message, channel, async (session, subscription, sendResponse, sendError) => {
+        this._apply_on_Subscription(node_opcua_service_subscription_1.CreateMonitoredItemsResponse, message, channel, async (_session, subscription, sendResponse, sendError) => {
             const timestampsToReturn = request.timestampsToReturn;
             if (timestampsToReturn === node_opcua_service_read_1.TimestampsToReturn.Invalid) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadTimestampsToReturnInvalid);
@@ -1968,7 +2190,9 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 const resultsPromise = request.itemsToCreate.map(async (monitoredItemCreateRequest) => {
                     const { monitoredItem, createResult } = subscription.preCreateMonitoredItem(addressSpace, timestampsToReturn, monitoredItemCreateRequest);
                     if (monitoredItem) {
-                        await options.onCreateMonitoredItem(subscription, monitoredItem);
+                        if (options.onCreateMonitoredItem) {
+                            await options.onCreateMonitoredItem(subscription, monitoredItem);
+                        }
                         subscription.postCreateMonitoredItem(monitoredItem, monitoredItemCreateRequest, createResult);
                     }
                     return createResult;
@@ -1995,7 +2219,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     _on_ModifySubscriptionRequest(message, channel) {
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.ModifySubscriptionRequest);
-        this._apply_on_Subscription(node_opcua_service_subscription_1.ModifySubscriptionResponse, message, channel, async (session, subscription, sendResponse, sendError) => {
+        this._apply_on_Subscription(node_opcua_service_subscription_1.ModifySubscriptionResponse, message, channel, async (_session, subscription, sendResponse, _sendError) => {
             subscription.modify(request);
             const response = new node_opcua_service_subscription_1.ModifySubscriptionResponse({
                 revisedLifetimeCount: subscription.lifeTimeCount,
@@ -2008,7 +2232,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     _on_ModifyMonitoredItemsRequest(message, channel) {
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.ModifyMonitoredItemsRequest);
-        this._apply_on_Subscription(node_opcua_service_subscription_1.ModifyMonitoredItemsResponse, message, channel, async (session, subscription, sendResponse, sendError) => {
+        this._apply_on_Subscription(node_opcua_service_subscription_1.ModifyMonitoredItemsResponse, message, channel, async (_session, subscription, sendResponse, sendError) => {
             const timestampsToReturn = request.timestampsToReturn;
             if (timestampsToReturn === node_opcua_service_read_1.TimestampsToReturn.Invalid) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadTimestampsToReturnInvalid);
@@ -2027,7 +2251,9 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 const monitoredItemId = item.monitoredItemId;
                 const monitoredItem = subscription.getMonitoredItem(monitoredItemId);
                 if (!monitoredItem) {
-                    return new node_opcua_service_subscription_1.MonitoredItemModifyResult({ statusCode: node_opcua_status_code_1.StatusCodes.BadMonitoredItemIdInvalid });
+                    return new node_opcua_service_subscription_1.MonitoredItemModifyResult({
+                        statusCode: node_opcua_status_code_1.StatusCodes.BadMonitoredItemIdInvalid
+                    });
                 }
                 // adjust samplingInterval if === -1
                 if (item.requestedParameters.samplingInterval === -1) {
@@ -2045,7 +2271,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     _on_PublishRequest(message, channel) {
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.PublishRequest);
-        this._apply_on_SessionObject(node_opcua_service_subscription_1.PublishResponse, message, channel, (session, sendResponse, sendError) => {
+        this._apply_on_SessionObject(node_opcua_service_subscription_1.PublishResponse, message, channel, (session, sendResponse, _sendError) => {
             (0, node_opcua_assert_1.assert)(session);
             (0, node_opcua_assert_1.assert)(session.publishEngine); // server.publishEngine doesn't exists, OPCUAServer has probably shut down already
             session.publishEngine._on_PublishRequest(request, (_request1, response) => {
@@ -2057,14 +2283,14 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.SetPublishingModeRequest);
         const publishingEnabled = request.publishingEnabled;
-        this._apply_on_Subscriptions(node_opcua_service_subscription_1.SetPublishingModeResponse, message, channel, async (session, subscription) => {
+        this._apply_on_Subscriptions(node_opcua_service_subscription_1.SetPublishingModeResponse, message, channel, async (_session, subscription) => {
             return subscription.setPublishingMode(publishingEnabled);
         });
     }
     _on_DeleteMonitoredItemsRequest(message, channel) {
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.DeleteMonitoredItemsRequest);
-        this._apply_on_Subscription(node_opcua_service_subscription_1.DeleteMonitoredItemsResponse, message, channel, async (session, subscription, sendResponse, sendError) => {
+        this._apply_on_Subscription(node_opcua_service_subscription_1.DeleteMonitoredItemsResponse, message, channel, async (_session, subscription, sendResponse, sendError) => {
             /* c8 ignore next */
             if (!request.monitoredItemIds || request.monitoredItemIds.length === 0) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadNothingToDo);
@@ -2101,7 +2327,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     _on_SetTriggeringRequest(message, channel) {
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.SetTriggeringRequest);
-        this._apply_on_Subscription(node_opcua_service_subscription_1.SetTriggeringResponse, message, channel, async (session, subscription, sendResponse, sendError) => {
+        this._apply_on_Subscription(node_opcua_service_subscription_1.SetTriggeringResponse, message, channel, async (_session, subscription, sendResponse, sendError) => {
             /* */
             const { triggeringItemId, linksToAdd, linksToRemove } = request;
             /**
@@ -2119,7 +2345,9 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             }
             const { addResults, removeResults, statusCode } = subscription.setTriggering(triggeringItemId, linksToAdd, linksToRemove);
             if (statusCode.isNotGood()) {
-                const response = new node_opcua_types_1.ServiceFault({ responseHeader: { serviceResult: statusCode } });
+                const response = new node_opcua_types_1.ServiceFault({
+                    responseHeader: { serviceResult: statusCode }
+                });
                 sendResponse(response);
             }
             else {
@@ -2138,12 +2366,16 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         if (!this.options.onDeleteMonitoredItem) {
             return;
         }
-        await subscription.applyOnMonitoredItem(this.options.onDeleteMonitoredItem.bind(null, subscription));
+        const t = this.options.onDeleteMonitoredItem.bind(null, subscription);
+        const functor = async (monitoredItem) => {
+            await t(monitoredItem);
+        };
+        await subscription.applyOnMonitoredItem(functor);
     }
     _on_RepublishRequest(message, channel) {
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.RepublishRequest);
-        this._apply_on_Subscription(node_opcua_service_subscription_1.RepublishResponse, message, channel, async (session, subscription, sendResponse, sendError) => {
+        this._apply_on_Subscription(node_opcua_service_subscription_1.RepublishResponse, message, channel, async (_session, subscription, sendResponse, sendError) => {
             // update diagnostic counter
             subscription.subscriptionDiagnostics.republishRequestCount += 1;
             subscription.subscriptionDiagnostics.republishMessageRequestCount += 1;
@@ -2170,7 +2402,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     _on_SetMonitoringModeRequest(message, channel) {
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.SetMonitoringModeRequest);
-        this._apply_on_Subscription(node_opcua_service_subscription_1.SetMonitoringModeResponse, message, channel, async (session, subscription, sendResponse, sendError) => {
+        this._apply_on_Subscription(node_opcua_service_subscription_1.SetMonitoringModeResponse, message, channel, async (_session, subscription, sendResponse, sendError) => {
             /* c8 ignore next */
             if (!request.monitoredItemIds || request.monitoredItemIds.length === 0) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadNothingToDo);
@@ -2203,7 +2435,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     _on_TranslateBrowsePathsToNodeIdsRequest(message, channel) {
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_translate_browse_path_1.TranslateBrowsePathsToNodeIdsRequest);
-        this._apply_on_SessionObject(node_opcua_service_translate_browse_path_1.TranslateBrowsePathsToNodeIdsResponse, message, channel, async (session, sendResponse, sendError) => {
+        this._apply_on_SessionObject(node_opcua_service_translate_browse_path_1.TranslateBrowsePathsToNodeIdsResponse, message, channel, async (_session, sendResponse, sendError) => {
             if (!request.browsePaths || request.browsePaths.length === 0) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadNothingToDo);
             }
@@ -2222,7 +2454,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 });
                 sendResponse(response);
             })
-                .catch((err) => {
+                .catch((_err) => {
                 sendError(node_opcua_status_code_1.StatusCodes.BadInternalError);
             });
         });
@@ -2236,7 +2468,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_call_1.CallRequest);
         this._apply_on_SessionObject(node_opcua_service_call_1.CallResponse, message, channel, (session, sendResponse, sendError) => {
-            let response;
             if (!request.methodsToCall || request.methodsToCall.length === 0) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadNothingToDo);
             }
@@ -2255,7 +2486,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 filterDiagnosticInfo(request.requestHeader.returnDiagnostics, response);
                 sendResponse(response);
             })
-                .catch((err) => {
+                .catch((_err) => {
                 sendError(node_opcua_status_code_1.StatusCodes.BadInternalError);
             });
         });
@@ -2306,7 +2537,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     }
     /* c8 ignore next */
     _on_Cancel(message, channel) {
-        return g_sendError(channel, message, node_opcua_types_1.CancelResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
+        g_sendError(channel, message, node_opcua_types_1.CancelResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
     }
     // NodeManagement Service Set Overview
     // This Service Set defines Services to add and delete AddressSpace Nodes and References between them. All added
@@ -2314,32 +2545,32 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     //
     /* c8 ignore next */
     _on_AddNodes(message, channel) {
-        return g_sendError(channel, message, node_opcua_service_node_management_1.AddNodesResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
+        g_sendError(channel, message, node_opcua_service_node_management_1.AddNodesResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
     }
     /* c8 ignore next */
     _on_AddReferences(message, channel) {
-        return g_sendError(channel, message, node_opcua_service_node_management_1.AddReferencesResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
+        g_sendError(channel, message, node_opcua_service_node_management_1.AddReferencesResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
     }
     /* c8 ignore next */
     _on_DeleteNodes(message, channel) {
-        return g_sendError(channel, message, node_opcua_service_node_management_1.DeleteNodesResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
+        g_sendError(channel, message, node_opcua_service_node_management_1.DeleteNodesResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
     }
     /* c8 ignore next */
     _on_DeleteReferences(message, channel) {
-        return g_sendError(channel, message, node_opcua_service_node_management_1.DeleteReferencesResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
+        g_sendError(channel, message, node_opcua_service_node_management_1.DeleteReferencesResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
     }
     // Query Service
     /* c8 ignore next */
     _on_QueryFirst(message, channel) {
-        return g_sendError(channel, message, node_opcua_service_query_1.QueryFirstResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
+        g_sendError(channel, message, node_opcua_service_query_1.QueryFirstResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
     }
     /* c8 ignore next */
     _on_QueryNext(message, channel) {
-        return g_sendError(channel, message, node_opcua_service_query_1.QueryNextResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
+        g_sendError(channel, message, node_opcua_service_query_1.QueryNextResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
     }
     /* c8 ignore next */
     _on_HistoryUpdate(message, channel) {
-        return g_sendError(channel, message, node_opcua_service_history_1.HistoryUpdateResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
+        g_sendError(channel, message, node_opcua_service_history_1.HistoryUpdateResponse, node_opcua_status_code_1.StatusCodes.BadServiceUnsupported);
     }
     createEndpoint(port1, serverOptions) {
         // add the tcp/ip endpoint with no security
@@ -2367,15 +2598,15 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         endpointOptions.hostname = endpointOptions.hostname || hostname;
         endpointOptions.port = endpointOptions.port === undefined ? 26543 : endpointOptions.port;
         /* c8 ignore next */
-        if (!Object.prototype.hasOwnProperty.call(endpointOptions, "port") ||
-            !isFinite(endpointOptions.port) ||
+        if (!Object.hasOwn(endpointOptions, "port") ||
+            !Number.isFinite(endpointOptions.port) ||
             typeof endpointOptions.port !== "number") {
             throw new Error("expecting a valid port (number) when specified. alternatively you can specify port:0 and node-opcua will choose the first available port");
         }
         const port = Number(endpointOptions.port || 0);
         const endPoint = this.createEndpoint(port, serverOption);
         endpointOptions.alternateHostname = endpointOptions.alternateHostname || [];
-        const alternateHostname = endpointOptions.alternateHostname instanceof Array
+        const alternateHostname = Array.isArray(endpointOptions.alternateHostname)
             ? endpointOptions.alternateHostname
             : [endpointOptions.alternateHostname];
         const allowAnonymous = endpointOptions.allowAnonymous === undefined ? true : !!endpointOptions.allowAnonymous;
@@ -2387,7 +2618,8 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             alternateHostname,
             disableDiscovery: !!endpointOptions.disableDiscovery,
             // xx                hostname,
-            resourcePath: serverOption.resourcePath || ""
+            resourcePath: serverOption.resourcePath || "",
+            advertisedEndpoints: endpointOptions.advertisedEndpoints,
             // TODO  userTokenTypes: endpointOptions.userTokenTypes || undefined,
             // TODO allowUnsecurePassword: endpointOptions.allowUnsecurePassword || false
         });
@@ -2397,6 +2629,10 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         await super.initializeCM();
         await this.userCertificateManager.initialize();
     }
+    // biome-ignore lint/suspicious/noExplicitAny: must match EventEmitter.on() signature
+    on(event, eventHandler) {
+        return super.on(event, eventHandler);
+    }
 }
 exports.OPCUAServer = OPCUAServer;
 const userIdentityTokenPasswordRemoved = (userIdentityToken) => {
@@ -2431,7 +2667,7 @@ function raiseAuditActivateSessionEventType(session) {
             sessionId: { dataType: "NodeId", value: session.nodeId },
             /* part 5 - 6.4.10 AuditActivateSessionEventType */
             clientSoftwareCertificates: {
-                arrayType: node_opcua_variant_2.VariantArrayType.Array,
+                arrayType: node_opcua_variant_1.VariantArrayType.Array,
                 dataType: "ExtensionObject" /* SignedSoftwareCertificate */,
                 value: []
             },
@@ -2446,12 +2682,14 @@ function raiseAuditActivateSessionEventType(session) {
             // use the same identifier in all AuditEvents related to the Session Service Set
             // (AuditCreateSessionEventType, AuditActivateSessionEventType and their subtypes) and
             // the SecureChannel Service Set (AuditChannelEventType and its subtypes).
-            secureChannelId: { dataType: "String", value: session.channel.channelId.toString() }
+            secureChannelId: {
+                dataType: "String",
+                value: session.channel?.channelId?.toString() ?? ""
+            }
         });
     }
 }
 const opts = { multiArgs: false };
-OPCUAServer.prototype.start = (0, thenify_ex_1.withCallback)(OPCUAServer.prototype.start, opts);
 OPCUAServer.prototype.initialize = (0, thenify_ex_1.withCallback)(OPCUAServer.prototype.initialize, opts);
 OPCUAServer.prototype.shutdown = (0, thenify_ex_1.withCallback)(OPCUAServer.prototype.shutdown, opts);
 //# sourceMappingURL=opcua_server.js.map