@iobroker/js-controller-adapter 7.2.3 → 8.0.0-alpha.2-20260923-99da17fcc

package/build/esm/lib/adapter/adapter.js

@@ -11,15 +11,19 @@ import extend from 'node.extend';
 import yargs from 'yargs/yargs';
 import fs from 'fs-extra';
 import * as url from 'node:url';
-import { PluginHandler } from '@iobroker/plugin-base';
 import { EXIT_CODES, getObjectsConstructor, getStatesConstructor, isInstalledFromNpm, logger, password, tools, } from '@iobroker/js-controller-common';
-import { decryptArray, encryptArray, getAdapterScopedPackageIdentifier, getSupportedFeatures, isMessageboxSupported, listInstalledNodeModules, requestModuleNameByUrl, deleteObjectAttribute, setObjectAttribute, getObjectAttribute, } from '../../lib/adapter/utils.js';
+import { decryptArray, encryptArray, getAdapterScopedPackageIdentifier, getSupportedFeatures, isMessageboxSupported, listInstalledNodeModules, requestModuleNameByUrl, deleteObjectAttribute, getObjectAttribute, } from '../../lib/adapter/utils.js';
 // local version is always the same as controller version, since lerna exact: true is used
 import packJson from '@iobroker/js-controller-adapter/package.json' with { type: 'json' };
 import { Log } from '../../lib/adapter/log.js';
 import { Validator } from './validator.js';
 import { ACCESS_EVERY_READ, ACCESS_EVERY_WRITE, ACCESS_GROUP_READ, ACCESS_GROUP_WRITE, ACCESS_USER_READ, ACCESS_USER_WRITE, ALIAS_STARTS_WITH, DEFAULT_SECRET, ERROR_PERMISSION, NO_PROTECT_ADAPTERS, STATE_QUALITY, SYSTEM_ADMIN_GROUP, SYSTEM_ADMIN_USER, } from '../../lib/adapter/constants.js';
+import { PluginHandler } from '@iobroker/plugin-base';
 import { UserInterfaceMessagingController } from '../../lib/adapter/userInterfaceMessagingController.js';
+import { AsyncAdapter } from '../../lib/adapter/asyncAdapter.js';
+import { CERTIFICATES_OBJECT_ID } from '../../lib/adapter/managers/CertificateManager.js';
+import { AliasManager } from '../../lib/adapter/managers/AliasManager.js';
+import { SubscriptionManager } from '../../lib/adapter/managers/SubscriptionManager.js';
 import { SYSTEM_ADAPTER_PREFIX, DEFAULT_OBJECTS_WARN_LIMIT } from '@iobroker/js-controller-common-db/constants';
 import { isLogLevel } from '@iobroker/js-controller-common-db/tools';
 const controllerVersion = packJson.version;
@@ -51,14 +55,10 @@ export class AdapterClass extends EventEmitter {
     startedInCompactMode;
     /** List of instances which want our logs */
     logList = new Set();
-    aliases = new Map();
-    aliasPatterns = new Set();
     enums = {};
     eventLoopLags = [];
     overwriteLogLevel = false;
     adapterReady = false;
-    /** Callbacks from sendTo */
-    messageCallbacks = new Map();
     /**
      * Contains a live cache of the adapter's states.
      * NOTE: This is only defined if the adapter was initialized with the option states: true.
@@ -70,7 +70,6 @@ export class AdapterClass extends EventEmitter {
      */
     oObjects;
     _stopInProgress = false;
-    _callbackId = 1;
     _firstConnection = true;
     _timers = new Set();
     _intervals = new Set();
@@ -79,12 +78,14 @@ export class AdapterClass extends EventEmitter {
     log;
     performStrictObjectChecks;
     _logger;
-    _restartScheduleJob;
+    _restartScheduleJob = null;
     _schedule;
     namespaceLog;
     namespace;
     name;
     _systemSecret;
+    /** Attributes of `encryptedNative`: their values in `this.config` are decrypted on start */
+    _decryptedNativeAttributes = new Array();
     /** Whether the adapter has already terminated */
     terminated = false;
     /** The cache of usernames */
@@ -97,8 +98,6 @@ export class AdapterClass extends EventEmitter {
     users = {}; // todo
     /** The cache of user groups */
     groups = {};
-    /** An array of instances, that support auto subscribe */
-    autoSubscribe = [];
     defaultHistory = null;
     pluginHandler;
     _reportInterval;
@@ -130,11 +129,9 @@ export class AdapterClass extends EventEmitter {
     /** latitude configured in system.config, only available if requested via AdapterOptions `useFormatDate`*/
     latitude;
     _defaultObjs;
-    _aliasObjectsSubscribed;
     config = {};
     host;
     common;
-    mboxSubscribed;
     /** Stop the adapter */
     stop;
     version;
@@ -162,6 +159,31 @@ export class AdapterClass extends EventEmitter {
     SUPPORTED_FEATURES = getSupportedFeatures();
     /** Controller for messaging related functionality */
     uiMessagingController;
+    /** Shared runtime context handed to managers */
+    #context;
+    #async;
+    #certWatchers = new Map();
+    #aliasInstance;
+    /** Lazily-constructed alias subscription manager. */
+    get #alias() {
+        return (this.#aliasInstance ??= new AliasManager(this.#context, (id, allowSystem, options) => this._utils.validateId(id, allowSystem, options)));
+    }
+    #subscriptionsInstance;
+    /** Lazily-constructed object/file/state subscription manager. */
+    get #subscriptions() {
+        return (this.#subscriptionsInstance ??= new SubscriptionManager(this.#context, (id, isPattern) => this._utils.fixId(id, isPattern), this.#alias, {
+            getForeignStateObjects: (pattern, options) => 
+            // @ts-expect-error adjust types
+            this.getForeignObjectsAsync(pattern, null, null, options),
+        }));
+    }
+    /** True once `system.certificates` is subscribed, i.e. certificates have been requested */
+    #certObjectSubscribed = false;
+    /** True once a certificate change scheduled a restart, so concurrent changes schedule only one */
+    #certRestartScheduled = false;
+    /**
+     * @param options Adapter options, or the adapter name as a string
+     */
     constructor(options) {
         super();
         // enable "const adapter = require(__dirname + '/../../lib/adapter.js')('adapterName');" call
@@ -299,6 +321,36 @@ export class AdapterClass extends EventEmitter {
             subscribeCallback: this._options.uiClientSubscribe,
             unsubscribeCallback: this._options.uiClientUnsubscribe,
         });
+        const self = this;
+        this.#context = {
+            logger: this._logger,
+            uiMessagingController: this.uiMessagingController,
+            countOutput: () => {
+                self.outputCount++;
+            },
+            get namespace() {
+                return self.namespace;
+            },
+            get namespaceLog() {
+                return self.namespaceLog;
+            },
+            get host() {
+                return self.host;
+            },
+            get states() {
+                return self.#states;
+            },
+            get objects() {
+                return self.#objects;
+            },
+            get common() {
+                return self.common;
+            },
+            get config() {
+                return self.config;
+            },
+        };
+        this.#async = new AsyncAdapter(this.#context);
         // Create dynamic methods
         /**
          * Promise-version of `Adapter.getPort`
@@ -320,10 +372,6 @@ export class AdapterClass extends EventEmitter {
          * Promise-version of `Adapter.calculatePermissions`
          */
         this.calculatePermissionsAsync = tools.promisifyNoError(this.calculatePermissions, this);
-        /**
-         * Promise-version of `Adapter.getCertificates`
-         */
-        this.getCertificatesAsync = tools.promisify(this.getCertificates, this);
         /**
          * Promise-version of `Adapter.setObject`
          */
@@ -508,10 +556,6 @@ export class AdapterClass extends EventEmitter {
          * Promise-version of `Adapter.fileExists`
          */
         this.fileExistsAsync = tools.promisify(this.fileExists, this);
-        /**
-         * Promise-version of `Adapter.sendToHost`
-         */
-        this.sendToHostAsync = tools.promisifyNoError(this.sendToHost, this);
         /**
          * Promise-version of `Adapter.setState`
          */
@@ -573,7 +617,7 @@ export class AdapterClass extends EventEmitter {
          */
         this.unsubscribeStatesAsync = tools.promisify(this.unsubscribeStates, this);
         this.setExecutableCapabilities = tools.setExecutableCapabilities;
-        this._init();
+        this._init().catch(e => this._logger.error(`${this.namespaceLog} Cannot initialize adapter: ${e.message}`));
     }
     /**
      * Get the adapter scoped package identifier of a node module
@@ -664,6 +708,12 @@ export class AdapterClass extends EventEmitter {
         return tools.encrypt(secretVal, value);
     }
     // unknown guard implementation
+    /**
+     * Read a session from the states DB
+     *
+     * @param id the session id
+     * @param callback return result
+     */
     getSession(id, callback) {
         Validator.assertString(id, 'id');
         Validator.assertCallback(callback, 'callback');
@@ -674,11 +724,19 @@ export class AdapterClass extends EventEmitter {
         if (!this.#states) {
             // if states is no longer existing, we do not need to unsubscribe
             this._logger.info(`${this.namespaceLog} getSession not processed because States database not connected`);
-            return tools.maybeCallbackWithError(options.callback, tools.ERRORS.ERROR_DB_CLOSED);
+            return tools.maybeCallback(options.callback, null);
         }
-        this.#states.getSession(options.id, options.callback);
+        this.#states.getSession(options.id, (err, session) => tools.maybeCallback(options.callback, session || null));
     }
     // unknown implementation guards
+    /**
+     * Store a session in the states DB
+     *
+     * @param id the session id
+     * @param ttl time to live in seconds
+     * @param data the session data to store
+     * @param callback return result
+     */
     setSession(id, ttl, data, callback) {
         Validator.assertString(id, 'id');
         Validator.assertOptionalCallback(callback, 'callback');
@@ -693,8 +751,16 @@ export class AdapterClass extends EventEmitter {
             this._logger.info(`${this.namespaceLog} setSession not processed because States database not connected`);
             return tools.maybeCallbackWithError(options.callback, tools.ERRORS.ERROR_DB_CLOSED);
         }
-        this.#states.setSession(options.id, options.ttl, options.data, options.callback);
+        return options.callback
+            ? this.#states.setSession(options.id, options.ttl, options.data, options.callback)
+            : this.#states.setSession(options.id, options.ttl, options.data);
     }
+    /**
+     * Destroy a session in the states DB
+     *
+     * @param id the session id
+     * @param callback return result
+     */
     destroySession(id, callback) {
         Validator.assertString(id, 'id');
         Validator.assertOptionalCallback(callback, 'callback');
@@ -706,12 +772,13 @@ export class AdapterClass extends EventEmitter {
             this._logger.info(`${this.namespaceLog} destroySession not processed because States database not connected`);
             return tools.maybeCallbackWithError(options.callback, tools.ERRORS.ERROR_DB_CLOSED);
         }
-        this.#states.destroySession(options.id, options.callback);
+        return options.callback
+            ? this.#states.destroySession(options.id, options.callback)
+            : this.#states.destroySession(options.id);
     }
     async _getObjectsByArray(keys, options) {
         try {
-            const res = await this.#objects.getObjects(keys, options);
-            return res;
+            return await this.#objects.getObjects(keys, options);
         }
         catch (e) {
             this._logger.error(`Could not get objects by array: ${e.message}`);
@@ -1066,7 +1133,7 @@ export class AdapterClass extends EventEmitter {
                 options.user = this.usernames[options.user].id;
             }
         }
-        this.getForeignObject(options.user, options, (err, obj) => {
+        this.getForeignObject(options.user, options.options, (err, obj) => {
             if (err || !obj) {
                 return tools.maybeCallbackWithError(options.callback, 'User does not exist');
             }
@@ -1156,11 +1223,11 @@ export class AdapterClass extends EventEmitter {
         if (options.group && !options.group.startsWith('system.group.')) {
             options.group = `system.group.${options.group}`;
         }
-        this.getForeignObject(options.user, options, (err, obj) => {
+        this.getForeignObject(options.user, options.options, (err, obj) => {
             if (err || !obj) {
                 return tools.maybeCallback(options.callback, false);
             }
-            this.getForeignObject(options.group, options, (err, obj) => {
+            return this.getForeignObject(options.group, options.options, (err, obj) => {
                 if (err || !obj) {
                     return tools.maybeCallback(options.callback, false);
                 }
@@ -1265,7 +1332,7 @@ export class AdapterClass extends EventEmitter {
      *        ```
      */
     calculatePermissions(user, commandsPermissions, options, callback) {
-        user = user || '';
+        user ||= '';
         if (typeof options === 'function') {
             callback = options;
             options = null;
@@ -1278,7 +1345,12 @@ export class AdapterClass extends EventEmitter {
             Validator.assertObject(options, 'options');
         }
         Validator.assertOptionalCallback(callback, 'callback');
-        return this._calculatePermissions({ user, commandsPermissions, options, callback });
+        return this._calculatePermissions({
+            user: user,
+            commandsPermissions,
+            options,
+            callback,
+        });
     }
     async _calculatePermissions(options) {
         const { user } = options;
@@ -1380,23 +1452,22 @@ export class AdapterClass extends EventEmitter {
                             for (const type of Object.keys(gAcl)) {
                                 // fix bug. Some version have user instead of users.
                                 if (type === 'user') {
-                                    // @ts-expect-error fix it
-                                    acl.users = acl.users || {};
+                                    acl.users ||= {};
                                 }
                                 else {
-                                    // @ts-expect-error fix it
-                                    acl[type] = acl[type] || {};
+                                    // @ts-expect-error fix later
+                                    acl[type] ||= {};
                                 }
                                 // @ts-expect-error fix it
                                 for (const op of Object.keys(gAcl[type])) {
                                     // fix error
                                     if (type === 'user') {
-                                        // @ts-expect-error fix it
-                                        acl.users[op] = acl.users[op] || gAcl.user[op];
+                                        // @ts-expect-error fix later
+                                        acl.users[op] ||= gAcl.user[op];
                                     }
                                     else {
-                                        // @ts-expect-error fix it
-                                        acl[type][op] = acl[type][op] || gAcl[type][op];
+                                        // @ts-expect-error fix later
+                                        acl[type][op] ||= gAcl[type][op];
                                     }
                                 }
                             }
@@ -1443,10 +1514,8 @@ export class AdapterClass extends EventEmitter {
                     this._delays.forEach(timer => clearTimeout(timer));
                     this._delays.clear();
                 }
-                if (this.messageCallbacks.size) {
-                    this.messageCallbacks.forEach(callbackObj => clearTimeout(callbackObj.timer));
-                    this.messageCallbacks.clear();
-                }
+                this.#async.clearPending();
+                await this.stopWatchingCertificates();
                 if (this.#states && updateAliveState) {
                     this.outputCount++;
                     try {
@@ -1467,11 +1536,14 @@ export class AdapterClass extends EventEmitter {
                     if (this._options.unload.length >= 1) {
                         // The method takes (at least) a callback
                         try {
-                            this._options.unload(finishUnload);
+                            const unloadResult = this._options.unload(finishUnload);
+                            if (unloadResult instanceof Promise) {
+                                unloadResult.catch(e => this._logger.error(`${this.namespaceLog} Error in unload: ${e.message}`));
+                            }
                         }
                         catch {
                             // Can only throw in unload logic, in this case the finishUnload() was not called
-                            finishUnload();
+                            finishUnload().catch(e => this._logger.error(`${this.namespaceLog} Error in finishUnload: ${e.message}`));
                         }
                     }
                     else {
@@ -1484,7 +1556,7 @@ export class AdapterClass extends EventEmitter {
                                 await unloadPromise;
                             }
                             finally {
-                                finishUnload();
+                                finishUnload().catch(e => this._logger.error(`${this.namespaceLog} Error in finishUnload: ${e.message}`));
                             }
                         }
                         else {
@@ -1514,30 +1586,105 @@ export class AdapterClass extends EventEmitter {
         }
     }
     /**
-     * Reads the file certificate from a given path and adds a file watcher to restart adapter on cert changes
-     * if a cert is passed it is returned as it is
+     * Installs a restart-on-change watcher for each file-backed certificate path, deduped by path.
+     * A change schedules a graceful restart so the adapter reloads the new certificate.
      *
-     * @param cert cert or path to cert
+     * @param paths file-backed certificate paths returned by the certificate manager
      */
-    _readFileCertificate(cert) {
-        if (typeof cert === 'string') {
+    #watchCertFiles(paths) {
+        for (const certFile of paths) {
+            if (this.#certWatchers.has(certFile)) {
+                continue;
+            }
             try {
-                // if length < 1024 it's no valid cert, so we assume a path to a valid certificate
-                if (cert.length < 1024 && fs.existsSync(cert)) {
-                    const certFile = cert;
-                    cert = fs.readFileSync(certFile, 'utf8');
-                    // start watcher of this file
-                    fs.watch(certFile, (eventType, filename) => {
-                        this._logger.warn(`${this.namespaceLog} New certificate "${filename}" detected. Restart adapter`);
-                        setTimeout(() => this._stop({ isPause: false, isScheduled: true }), 2_000);
-                    });
-                }
+                const watcher = fs.watch(certFile, (_eventType, filename) => {
+                    this.#scheduleCertificateRestart(`New certificate "${filename}" detected`);
+                });
+                this.#certWatchers.set(certFile, watcher);
             }
             catch (e) {
-                this._logger.error(`${this.namespaceLog} Could not read certificate from file ${cert}: ${e.message}`);
+                this._logger.error(`${this.namespaceLog} Cannot watch certificate file ${certFile}: ${e.message}`);
+            }
+        }
+    }
+    /**
+     * Schedules a graceful restart, so the adapter reloads its certificates. Called by both the
+     * file watchers and the `system.certificates` subscription; the first caller wins, so a change
+     * seen through both channels restarts the adapter only once.
+     *
+     * @param reason human-readable cause, logged as a warning
+     */
+    #scheduleCertificateRestart(reason) {
+        if (this.#certRestartScheduled) {
+            return;
+        }
+        this.#certRestartScheduled = true;
+        this._logger.warn(`${this.namespaceLog} ${reason}. Restart adapter`);
+        setTimeout(() => this._stop({ isPause: false, isScheduled: true }), 2_000);
+    }
+    /**
+     * Subscribes to the `system.certificates` object, so inline (text) certificates are watched the
+     * same way file-backed ones are watched on disk. Subscribing on the system level channel keeps
+     * these events out of the adapter's own `objectChange` handler.
+     *
+     * Called after certificates have been requested, so only adapters actually using certificates
+     * pay for the subscription.
+     */
+    async #subscribeCertObject() {
+        if (this.#certObjectSubscribed || !this.#objects) {
+            return;
+        }
+        // set before awaiting, so concurrent getCertificates calls subscribe only once
+        this.#certObjectSubscribed = true;
+        try {
+            await this.#objects.subscribeAsync(CERTIFICATES_OBJECT_ID);
+            // stopWatchingCertificates() may have run while we were awaiting; it cleared the flag but could
+            // not unsubscribe a subscription that did not exist yet, so undo it now to avoid a leak.
+            if (!this.#certObjectSubscribed && this.#objects) {
+                await this.#objects.unsubscribeAsync(CERTIFICATES_OBJECT_ID);
+            }
+        }
+        catch (e) {
+            this.#certObjectSubscribed = false;
+            this._logger.error(`${this.namespaceLog} Cannot watch certificate object ${CERTIFICATES_OBJECT_ID}: ${e.message}`);
+        }
+    }
+    /**
+     * Tears down the certificate watching installed by {@link getCertificatesAsync}: closes the file
+     * watchers, unsubscribes from `system.certificates`, and forgets the certificates handed out by the
+     * last call, so a later change no longer schedules a restart. Called on adapter stop.
+     */
+    async stopWatchingCertificates() {
+        for (const watcher of this.#certWatchers.values()) {
+            watcher.close();
+        }
+        this.#certWatchers.clear();
+        this.#certRestartScheduled = false;
+        this.#async.stopWatchingCertificates();
+        if (this.#certObjectSubscribed && this.#objects) {
+            this.#certObjectSubscribed = false;
+            try {
+                await this.#objects.unsubscribeAsync(CERTIFICATES_OBJECT_ID);
+            }
+            catch {
+                // ignore, e.g. when the objects DB is already gone
             }
         }
-        return cert;
+    }
+    /**
+     * Loads SSL certificates by name and installs restart-on-change watchers: file watchers for
+     * file-backed certificate values, and a subscription to `system.certificates` covering inline
+     * ones and repointed paths.
+     *
+     * @param publicName public certificate name (defaults to `config.certPublic`)
+     * @param privateName private key name (defaults to `config.certPrivate`)
+     * @param chainedName chained certificate name (defaults to `config.certChained`)
+     */
+    async getCertificatesAsync(publicName, privateName, chainedName) {
+        const { certs, useLetsEncrypt, certFilePaths } = await this.#async.getCertificates(publicName, privateName, chainedName);
+        this.#watchCertFiles(certFilePaths);
+        await this.#subscribeCertObject();
+        return [certs, useLetsEncrypt];
     }
     /**
      * returns SSL certificates by name
@@ -1571,68 +1718,16 @@ export class AdapterClass extends EventEmitter {
             callback = chainedName;
             chainedName = undefined;
         }
-        const config = this.config;
-        publicName = publicName || config.certPublic;
-        privateName = privateName || config.certPrivate;
-        chainedName = chainedName || config.certChained;
-        if (publicName !== undefined) {
-            Validator.assertString(publicName, 'publicName');
-        }
-        if (privateName !== undefined) {
-            Validator.assertString(privateName, 'privateName');
-        }
-        if (chainedName !== undefined) {
-            Validator.assertString(chainedName, 'chainedName');
-        }
         Validator.assertOptionalCallback(callback, 'callback');
-        return this._getCertificates({ publicName, privateName, chainedName, callback });
-    }
-    async _getCertificates(options) {
-        const { publicName, chainedName, privateName, callback } = options;
-        let obj;
-        if (!this.#objects) {
-            this._logger.info(`${this.namespaceLog} getCertificates not processed because Objects database not connected`);
-            return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
-        }
-        try {
-            // Load certificates
-            obj = await this.#objects.getObject('system.certificates');
-        }
-        catch {
-            // ignore
-        }
-        if (!obj ||
-            !obj.native.certificates ||
-            !publicName ||
-            !privateName ||
-            !obj.native.certificates[publicName] ||
-            !obj.native.certificates[privateName] ||
-            (chainedName && !obj.native.certificates[chainedName])) {
-            this._logger.error(`${this.namespaceLog} Cannot configure secure web server, because no certificates found: ${publicName}, ${privateName}, ${chainedName}`);
-            if (publicName === 'defaultPublic' || privateName === 'defaultPrivate') {
-                this._logger.info(`${this.namespaceLog} Default certificates seem to be configured but missing. You can execute "iobroker cert create" in your shell to create these.`);
-            }
-            return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_NOT_FOUND);
-        }
-        let ca;
-        if (chainedName) {
-            const chained = this._readFileCertificate(obj.native.certificates[chainedName]).split('-----END CERTIFICATE-----\r\n');
-            // it is still a file name, and the file maybe does not exist, but we can omit this error
-            if (chained.join('').length >= 512) {
-                const caArr = [];
-                for (const cert of chained) {
-                    if (cert.replace(/(\r\n|\r|\n)/g, '').trim()) {
-                        caArr.push(`${cert}-----END CERTIFICATE-----\r\n`);
-                    }
-                }
-                ca = caArr.join('');
-            }
+        const cb = callback;
+        if (typeof cb === 'function') {
+            return this.getCertificatesAsync(publicName, privateName, chainedName).then(([certs, useLetsEncrypt]) => {
+                cb(null, certs, useLetsEncrypt);
+            }, (err) => {
+                cb(err);
+            });
         }
-        return tools.maybeCallbackWithError(callback, null, {
-            key: this._readFileCertificate(obj.native.certificates[privateName]),
-            cert: this._readFileCertificate(obj.native.certificates[publicName]),
-            ca,
-        }, obj.native.letsEncrypt);
+        return this.getCertificatesAsync(publicName, privateName, chainedName);
     }
     /**
      * Restarts an instance of the adapter.
@@ -1641,7 +1736,7 @@ export class AdapterClass extends EventEmitter {
     restart() {
         if (this.stop) {
             this._logger.warn(`${this.namespaceLog} Restart initiated`);
-            this.stop();
+            this.stop().catch(e => this._logger.error(`${this.namespaceLog} Cannot stop adapter: ${e.message}`));
         }
         else {
             this._logger.warn(`${this.namespaceLog} Cannot initiate restart, because this.stop is not defined`);
@@ -1667,7 +1762,7 @@ export class AdapterClass extends EventEmitter {
         const configObjId = `system.adapter.${this.namespace}`;
         let obj;
         try {
-            obj = await this.getForeignObjectAsync(configObjId);
+            obj = (await this.getForeignObjectAsync(configObjId));
         }
         catch (e) {
             this._logger.error(`${this.namespaceLog} Updating the adapter config failed: ${e.message}`);
@@ -1711,7 +1806,7 @@ export class AdapterClass extends EventEmitter {
         return this.setForeignObjectAsync(configObjId, obj);
     }
     /**
-     * Reads the encrypted parameter from config.
+     * Reads a parameter which is stored encrypted and returns its decrypted value.
      *
      * It returns promise if no callback is provided.
      *
@@ -1726,14 +1821,16 @@ export class AdapterClass extends EventEmitter {
     async _getEncryptedConfig(options) {
         const { attribute, callback } = options;
         const value = getObjectAttribute(this.config, attribute);
+        // `encryptedNative` says which attributes are stored encrypted, and the start decrypted exactly
+        // those in place - decrypting again cannot be detected, because a value carries no mark saying so
+        if ((Array.isArray(value) || typeof value === 'string') &&
+            this._decryptedNativeAttributes.includes(attribute)) {
+            return tools.maybeCallbackWithError(callback, null, value);
+        }
         if (Array.isArray(value)) {
             const secret = await this.getSystemSecret();
-            const result = [];
-            for (let i = 0; i < value.length; i++) {
-                if (typeof value[i] === 'string') {
-                    result[i] = tools.decrypt(secret, value[i]);
-                }
-            }
+            // entries that are not a string (e.g. an element without this attribute) are returned as they are
+            const result = value.map(item => (typeof item === 'string' ? tools.decrypt(secret, item) : item));
             return tools.maybeCallbackWithError(callback, null, result);
         }
         else if (typeof value === 'string') {
@@ -2120,7 +2217,7 @@ export class AdapterClass extends EventEmitter {
      * }
      * ```
      *
-     * If following object will be passed as argument
+     * If the following object will be passed as an argument
      *
      * ```js
      * {
@@ -2231,36 +2328,29 @@ export class AdapterClass extends EventEmitter {
                 this._logger.error(`${this.namespaceLog} Object ${options.id} not exist!`);
                 oldObj = {};
             }
-            if (options.obj.native &&
-                'repositories' in options.obj.native &&
-                oldObj.native &&
-                oldObj.native.repositories) {
-                oldObj.native.repositories = [];
+            if (options.obj.native && 'repositories' in options.obj.native && oldObj.native?.repositories) {
+                oldObj.native.repositories = {};
             }
-            if (options.obj.common && 'members' in options.obj.common && oldObj.common && oldObj.common.members) {
+            if (options.obj.common && 'members' in options.obj.common && oldObj.common?.members) {
                 oldObj.common.members = [];
             }
-            if (options.obj.native &&
-                'certificates' in options.obj.native &&
-                oldObj.native &&
-                oldObj.native.certificates) {
-                oldObj.native.certificates = [];
+            if (options.obj.native && 'certificates' in options.obj.native && oldObj.native?.certificates) {
+                oldObj.native.certificates = {};
             }
-            if (options.obj.native && 'devices' in options.obj.native && oldObj.native && oldObj.native.devices) {
+            if (options.obj.native && 'devices' in options.obj.native && oldObj.native?.devices) {
                 oldObj.native.devices = [];
             }
-            options.obj.from = options.obj.from || `system.adapter.${this.namespace}`;
-            options.obj.user = options.obj.user || (options.options ? options.options.user : '') || SYSTEM_ADMIN_USER;
-            options.obj.ts = options.obj.ts || Date.now();
+            options.obj.from ||= `system.adapter.${this.namespace}`;
+            options.obj.user ||= (options.options ? options.options.user : '') || SYSTEM_ADMIN_USER;
+            options.obj.ts ||= Date.now();
             options.obj = extend(true, oldObj, options.obj);
             // @ts-expect-error TODO we are returning type Object for ease of use to devs, but formally these are AnyObjects, e.g. not guaranteed to have common
             return this.#objects.setObject(options.id, options.obj, options.options, options.callback);
         }
-        options.obj.from = options.obj.from || `system.adapter.${this.namespace}`;
-        options.obj.user = options.obj.user || (options.options ? options.options.user : '') || SYSTEM_ADMIN_USER;
-        options.obj.ts = options.obj.ts || Date.now();
-        if ((options.obj.type && options.obj.type === 'state') ||
-            (!options.obj.type && oldObj && oldObj.type === 'state')) {
+        options.obj.from ||= `system.adapter.${this.namespace}`;
+        options.obj.user ||= (options.options ? options.options.user : '') || SYSTEM_ADMIN_USER;
+        options.obj.ts ||= Date.now();
+        if (options.obj?.type === 'state' || (!options.obj.type && oldObj?.type === 'state')) {
             if (options.obj.common &&
                 'custom' in options.obj.common &&
                 options.obj.common.custom !== null &&
@@ -2276,17 +2366,17 @@ export class AdapterClass extends EventEmitter {
             }
         }
         if (!oldObj) {
-            // if old object is not existing we behave like setObject
+            // if old object is not existing, we behave like setObject
             return this.setForeignObject(options.id, options.obj, options.options, options.callback);
         }
         try {
-            const cbObj = await this.#objects.extendObjectAsync(options.id, options.obj, options.options || {});
+            const cbObj = await this.#objects.extendObject(options.id, options.obj, options.options);
             let defState;
             if (options.obj.type === 'state' || oldObj.type === 'state') {
                 if (options.obj.common && 'def' in options.obj.common && options.obj.common.def !== undefined) {
                     defState = options.obj.common.def;
                 }
-                else if (oldObj.common && oldObj.common.def !== undefined) {
+                else if (oldObj.common?.def !== undefined) {
                     defState = oldObj.common.def;
                 }
             }
@@ -2464,29 +2554,32 @@ export class AdapterClass extends EventEmitter {
                 this._logger.error(`${this.namespaceLog} Object ${id} not exist!`);
                 oldObj = {};
             }
-            if (obj.native && 'repositories' in obj.native && oldObj.native && oldObj.native.repositories) {
-                oldObj.native.repositories = [];
+            if (obj.native &&
+                'repositories' in obj.native &&
+                oldObj.native?.repositories) {
+                oldObj.native.repositories = {};
             }
-            if (obj.common && 'members' in obj.common && oldObj.common && oldObj.common.members) {
+            if (obj.common && 'members' in obj.common && oldObj.common?.members) {
                 oldObj.common.members = [];
             }
-            if (obj.native && 'certificates' in obj.native && oldObj.native && oldObj.native.certificates) {
-                oldObj.native.certificates = [];
+            if (obj.native && 'certificates' in obj.native && oldObj.native?.certificates) {
+                oldObj.native.certificates = {};
             }
-            if (obj.native && 'devices' in obj.native && oldObj.native && oldObj.native.devices) {
+            if (obj.native && 'devices' in obj.native && oldObj.native?.devices) {
                 oldObj.native.devices = [];
             }
-            obj.from = obj.from || `system.adapter.${this.namespace}`;
-            obj.user = obj.user || options?.user || SYSTEM_ADMIN_USER;
-            obj.ts = obj.ts || Date.now();
+            obj.from ||= `system.adapter.${this.namespace}`;
+            obj.user ||= options?.user || SYSTEM_ADMIN_USER;
+            obj.ts ||= Date.now();
             obj = extend(true, oldObj, obj);
-            // @ts-expect-error TODO we are returning type Object for ease of use to devs, but formally these are AnyObjects, e.g. not guaranteed to have common
-            return this.#objects.setObject(id, obj, options, callback);
-        }
-        obj.from = obj.from || `system.adapter.${this.namespace}`;
-        obj.user = obj.user || options?.user || SYSTEM_ADMIN_USER;
-        obj.ts = obj.ts || Date.now();
-        if ((obj.type && obj.type === 'state') || (!obj.type && oldObj && oldObj.type === 'state')) {
+            return callback
+                ? this.#objects.setObject(id, obj, options, callback)
+                : this.#objects.setObject(id, obj, options);
+        }
+        obj.from ||= `system.adapter.${this.namespace}`;
+        obj.user ||= options?.user || SYSTEM_ADMIN_USER;
+        obj.ts ||= Date.now();
+        if ((obj.type && obj.type === 'state') || (!obj.type && oldObj?.type === 'state')) {
             if (obj.common &&
                 'custom' in obj.common &&
                 obj.common.custom !== null &&
@@ -2506,13 +2599,13 @@ export class AdapterClass extends EventEmitter {
             return this.setForeignObject(id, obj, options, callback);
         }
         try {
-            const cbObj = await this.#objects.extendObjectAsync(id, obj, options || {});
+            const cbObj = await this.#objects.extendObject(id, obj, options);
             if (cbObj?.value.type === 'state') {
                 let defState;
-                if (obj.common && 'def' in obj.common && obj.common.def !== undefined) {
+                if (obj.common && 'def' in obj.common && obj.common?.def !== undefined) {
                     defState = obj.common.def;
                 }
-                else if (oldObj.common && oldObj.common.def !== undefined) {
+                else if (oldObj.common?.def !== undefined) {
                     defState = oldObj.common.def;
                 }
                 if (defState !== undefined) {
@@ -2650,7 +2743,7 @@ export class AdapterClass extends EventEmitter {
         Validator.assertString(design, 'design');
         Validator.assertString(search, 'search');
         Validator.assertOptionalCallback(callback, 'callback');
-        params = params || {};
+        params ||= {};
         Validator.assertObject(params, 'params');
         if (options !== null && options !== undefined) {
             Validator.assertObject(options, 'options');
@@ -2919,9 +3012,7 @@ export class AdapterClass extends EventEmitter {
                         if (!parts[2]) {
                             continue;
                         }
-                        if (!result[`${parts[0]}.${parts[1]}`]) {
-                            result[`${parts[0]}.${parts[1]}`] = {};
-                        }
+                        result[`${parts[0]}.${parts[1]}`] ||= {};
                         result[`${parts[0]}.${parts[1]}`][row.id] = row.value;
                     }
                 }
@@ -3146,7 +3237,7 @@ export class AdapterClass extends EventEmitter {
      * @param options optional user context with language
      * @param options.user current user
      * @param options.language language in which the search must be done for multi-language names
-     * @result if the object was found by ID it will return id and may be the multi-language name it exists. If the object was found by name it will return id and the multi-language name. If the object was not found, it will return only name that was searched for.
+     * @returns if the object was found by ID it will return id and may be the multi-language name it exists. If the object was found by name it will return id and the multi-language name. If the object was not found, it will return only name that was searched for.
      */
     findForeignObjectAsync(id, type, options) {
         return new Promise((resolve, reject) => this.findForeignObject(id, type, options || {}, (err, id, name) => {
@@ -3188,7 +3279,7 @@ export class AdapterClass extends EventEmitter {
         catch (e) {
             return tools.maybeCallbackWithError(callback, e);
         }
-        return this._getForeignObject({ id, options, callback });
+        return this._getForeignObject({ id: id, options, callback });
     }
     async _getForeignObject(options) {
         if (!this.#objects) {
@@ -3196,14 +3287,12 @@ export class AdapterClass extends EventEmitter {
             return tools.maybeCallbackWithError(options.callback, tools.ERRORS.ERROR_DB_CLOSED);
         }
         try {
-            const obj = await this.#objects.getObjectAsync(options.id, options);
+            const obj = await this.#objects.getObjectAsync(options.id, options.options);
             // remove protectedNative if not admin, not cloud or not own adapter
-            if (obj &&
+            if (obj?.native &&
                 'protectedNative' in obj &&
                 Array.isArray(obj.protectedNative) &&
-                obj._id &&
-                obj._id.startsWith('system.adapter.') &&
-                obj.native &&
+                obj._id?.startsWith('system.adapter.') &&
                 !NO_PROTECT_ADAPTERS.includes(this.name) &&
                 this.name !== obj._id.split('.')[2]) {
                 for (const attr of obj.protectedNative) {
@@ -3240,31 +3329,35 @@ export class AdapterClass extends EventEmitter {
         // @ts-expect-error we have ensured that it is string for the rest the method will validate again
         this.delForeignObject(id, options, callback);
     }
-    _deleteObjects(tasks, options, cb) {
-        if (!tasks || !tasks.length) {
+    async _deleteObjects(tasks, options, cb) {
+        if (!tasks?.length) {
             return tools.maybeCallback(cb);
         }
-        const task = tasks.shift();
-        this.#objects.delObject(task.id, options, async (err) => {
-            if (err) {
-                return tools.maybeCallbackWithError(cb, err);
-            }
-            if (task.state) {
+        try {
+            for (const task of tasks) {
+                await new Promise((resolve, reject) => this.#objects.delObject(task.id, options, err => {
+                    err ? reject(err) : resolve();
+                }));
+                if (task.state) {
+                    try {
+                        await this.delForeignStateAsync(task.id, options);
+                    }
+                    catch (e) {
+                        this._logger.warn(`${this.namespaceLog} Could not remove state of ${task.id}: ${e.message}`);
+                    }
+                }
                 try {
-                    await this.delForeignStateAsync(task.id, options);
+                    await tools.removeIdFromAllEnums(this.#objects, task.id, this.enums);
                 }
                 catch (e) {
-                    this._logger.warn(`${this.namespaceLog} Could not remove state of ${task.id}: ${e.message}`);
+                    this._logger.warn(`${this.namespaceLog} Could not remove ${task.id} from enums: ${e.message}`);
                 }
             }
-            try {
-                await tools.removeIdFromAllEnums(this.#objects, task.id, this.enums);
-            }
-            catch (e) {
-                this._logger.warn(`${this.namespaceLog} Could not remove ${task.id} from enums: ${e.message}`);
-            }
-            setImmediate(() => this._deleteObjects(tasks, options, cb));
-        });
+        }
+        catch (err) {
+            return tools.maybeCallbackWithError(cb, err);
+        }
+        return tools.maybeCallback(cb);
     }
     /**
      * Delete any object.
@@ -3316,11 +3409,10 @@ export class AdapterClass extends EventEmitter {
                 const selector = { startkey: `${id}.`, endkey: `${id}.\u9999` };
                 // read all underlying states
                 this.#objects.getObjectList(selector, options, (err, res) => {
-                    res &&
-                        res.rows.forEach((item) => !tasks.find(task => task.id === item.id) &&
-                            (!item.value || !item.value.common || !item.value.common.dontDelete) && // exclude objects with dontDelete flag
-                            tasks.push({ id: item.id, state: item.value && item.value.type === 'state' }));
-                    this._deleteObjects(tasks, options, callback);
+                    res?.rows.forEach((item) => !tasks.find(task => task.id === item.id) &&
+                        !item.value?.common?.dontDelete && // exclude objects with dontDelete flag
+                        tasks.push({ id: item.id, state: item.value?.type === 'state' }));
+                    return this._deleteObjects(tasks, options, callback);
                 });
             });
         }
@@ -3329,7 +3421,7 @@ export class AdapterClass extends EventEmitter {
                 if (err) {
                     return tools.maybeCallbackWithError(callback, err);
                 }
-                else if (obj) {
+                if (obj) {
                     // do not allow deletion of objects with dontDelete flag
                     if (obj.common?.dontDelete) {
                         return tools.maybeCallbackWithError(callback, new Error('not deletable'));
@@ -3381,17 +3473,10 @@ export class AdapterClass extends EventEmitter {
         if (options !== null && options !== undefined) {
             Validator.assertObject(options, 'options');
         }
-        if (!this.#objects) {
-            this._logger.info(`${this.namespaceLog} subscribeObjects not processed because Objects database not connected`);
-            return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
-        }
-        if (pattern === '*') {
-            this.#objects.subscribeUser(`${this.namespace}.*`, options, callback);
-        }
-        else {
-            const fixedPattern = Array.isArray(pattern) ? pattern : this._utils.fixId(pattern, true);
-            this.#objects.subscribeUser(fixedPattern, options, callback);
-        }
+        const cb = callback;
+        this.#subscriptions
+            .subscribeObjects(pattern, options)
+            .then(() => cb?.(), (err) => cb?.(err));
     }
     /**
      * Unsubscribe on the changes of objects in this instance.
@@ -3415,17 +3500,10 @@ export class AdapterClass extends EventEmitter {
         if (options !== null && options !== undefined) {
             Validator.assertObject(options, 'options');
         }
-        if (!this.#objects) {
-            this._logger.info(`${this.namespaceLog} unsubscribeObjects not processed because Objects database not connected`);
-            return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
-        }
-        if (pattern === '*') {
-            this.#objects.unsubscribeUser(`${this.namespace}.*`, options, callback);
-        }
-        else {
-            const fixedPattern = Array.isArray(pattern) ? pattern : this._utils.fixId(pattern, true);
-            this.#objects.unsubscribeUser(fixedPattern, options, callback);
-        }
+        const cb = callback;
+        this.#subscriptions
+            .unsubscribeObjects(pattern, options)
+            .then(() => cb?.(), (err) => cb?.(err));
     }
     /**
      * Subscribe for the changes of objects in any instance.
@@ -3449,11 +3527,10 @@ export class AdapterClass extends EventEmitter {
         if (options !== null && options !== undefined) {
             Validator.assertObject(options, 'options');
         }
-        if (!this.#objects) {
-            this._logger.info(`${this.namespaceLog} subscribeForeignObjects not processed because Objects database not connected`);
-            return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
-        }
-        this.#objects.subscribeUser(pattern, options, callback);
+        const cb = callback;
+        this.#subscriptions
+            .subscribeForeignObjects(pattern, options)
+            .then(() => cb?.(), (err) => cb?.(err));
     }
     /**
      * Unsubscribe for the patterns on all objects.
@@ -3480,11 +3557,10 @@ export class AdapterClass extends EventEmitter {
         if (options !== null && options !== undefined) {
             Validator.assertObject(options, 'options');
         }
-        if (!this.#objects) {
-            this._logger.info(`${this.namespaceLog} unsubscribeForeignObjects not processed because Objects database not connected`);
-            return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
-        }
-        this.#objects.unsubscribeUser(pattern, options, callback);
+        const cb = callback;
+        this.#subscriptions
+            .unsubscribeForeignObjects(pattern, options)
+            .then(() => cb?.(), (err) => cb?.(err));
     }
     /**
      * Subscribe for the changes of files in specific instance.
@@ -3494,16 +3570,12 @@ export class AdapterClass extends EventEmitter {
      * @param options optional user context
      */
     subscribeForeignFiles(id, pattern, options) {
-        if (!this.#objects) {
-            this._logger.info(`${this.namespaceLog} subscribeForeignFiles not processed because Objects database not connected`);
-            throw new Error(tools.ERRORS.ERROR_DB_CLOSED);
-        }
         Validator.assertString(id, 'id');
         Validator.assertPattern(pattern, 'pattern');
         if (options !== null && options !== undefined) {
             Validator.assertObject(options, 'options');
         }
-        return this.#objects.subscribeUserFile(id, pattern, options);
+        return this.#subscriptions.subscribeForeignFiles(id, pattern, options);
     }
     /**
      * Unsubscribe for the changes of files on specific instance.
@@ -3516,16 +3588,12 @@ export class AdapterClass extends EventEmitter {
         if (!pattern) {
             pattern = '*';
         }
-        if (!this.#objects) {
-            this._logger.info(`${this.namespaceLog} unsubscribeForeignFiles not processed because Objects database not connected`);
-            throw new Error(tools.ERRORS.ERROR_DB_CLOSED);
-        }
         Validator.assertString(id, 'id');
         Validator.assertPattern(pattern, 'pattern');
         if (options !== null && options !== undefined) {
             Validator.assertObject(options, 'options');
         }
-        return this.#objects.unsubscribeUserFile(id, pattern, options);
+        return this.#subscriptions.unsubscribeForeignFiles(id, pattern, options);
     }
     /**
      * Same as {@link AdapterClass.setObject}, but with check if the object exists.
@@ -3680,11 +3748,11 @@ export class AdapterClass extends EventEmitter {
         return id;
     }
     /**
-     * @param deviceName
-     * @param common
-     * @param _native
-     * @param options
-     * @param callback
+     * @param deviceName the name of the device
+     * @param common the common section of the device object
+     * @param _native the native section of the device object
+     * @param options optional user context
+     * @param callback return result
      * @deprecated use `this.extendObject` instead
      */
     createDevice(deviceName, common, _native, options, callback) {
@@ -3715,31 +3783,34 @@ export class AdapterClass extends EventEmitter {
             deviceName,
             _native,
             callback,
-            options,
+            options: options,
         });
     }
     _createDevice(_options) {
         let { common, deviceName, _native } = _options;
         const { callback, options } = _options;
-        common = common || {};
-        common.name = common.name || deviceName;
+        common ||= {};
+        common.name ||= deviceName;
         deviceName = deviceName.replace(FORBIDDEN_CHARS, '_').replace(/\./g, '_');
         _native = _native || {};
-        this.setObjectNotExists(deviceName, {
+        const createResult = this.setObjectNotExists(deviceName, {
             type: 'device',
             common: common,
             native: _native,
         }, options, callback);
+        if (createResult instanceof Promise) {
+            createResult.catch(e => this._logger.error(`${this.namespaceLog} Cannot create device: ${e.message}`));
+        }
     }
     /**
      * Name of channel must be in format "channel"
      *
-     * @param parentDevice
-     * @param channelName
-     * @param roleOrCommon
-     * @param _native
-     * @param options
-     * @param callback
+     * @param parentDevice the parent device name
+     * @param channelName the name of the channel
+     * @param roleOrCommon role string or the common section of the channel object
+     * @param _native the native section of the channel object
+     * @param options optional user context
+     * @param callback return result
      * @deprecated use `this.extendObject` instead
      */
     createChannel(parentDevice, channelName, roleOrCommon, _native, options, callback) {
@@ -3773,29 +3844,30 @@ export class AdapterClass extends EventEmitter {
         Validator.assertString(channelName, 'channelName');
         Validator.assertString(parentDevice, 'parentDevice');
         Validator.assertOptionalCallback(callback, 'callback');
-        common.name = common.name || channelName;
+        common.name ||= channelName;
         if (parentDevice) {
             parentDevice = parentDevice.replace(FORBIDDEN_CHARS, '_').replace(/\./g, '_');
         }
         channelName = channelName.replace(FORBIDDEN_CHARS, '_').replace(/\./g, '_');
         // @ts-expect-error ts somehow loses types here
         channelName = this._DCS2ID(parentDevice, channelName);
-        _native = _native || {};
+        _native ||= {};
         const obj = {
+            _id: channelName,
             type: 'channel',
-            common: common,
+            common,
             native: _native,
         };
-        this.setObjectNotExists(channelName, obj, options, callback);
+        return this.setObjectNotExists(channelName, obj, options, callback);
     }
     /**
-     * @param parentDevice
-     * @param parentChannel
-     * @param stateName
-     * @param roleOrCommon
-     * @param _native
-     * @param options
-     * @param callback
+     * @param parentDevice the parent device name
+     * @param parentChannel the parent channel name
+     * @param stateName the name of the state
+     * @param roleOrCommon role string or the common section of the state object
+     * @param _native the native section of the state object
+     * @param options optional user context
+     * @param callback return result
      * @deprecated use `this.extendObject` instead
      */
     createState(parentDevice, parentChannel, stateName, roleOrCommon, _native, options, callback) {
@@ -3822,12 +3894,13 @@ export class AdapterClass extends EventEmitter {
                 write: false,
                 name: '',
                 role: roleOrCommon,
+                type: 'mixed',
             };
         }
         else if (tools.isObject(roleOrCommon)) {
             common = roleOrCommon;
         }
-        _native = _native || {};
+        _native ||= {};
         Validator.assertObject(common, 'common');
         Validator.assertString(stateName, 'stateName');
         Validator.assertString(parentDevice, 'parentDevice');
@@ -3842,9 +3915,9 @@ export class AdapterClass extends EventEmitter {
     _createState(_options) {
         const { _native, common, callback, options } = _options;
         let { parentChannel, parentDevice, stateName } = _options;
-        common.name = common.name || stateName;
-        common.read = common.read === undefined ? true : common.read;
-        common.write = common.write === undefined ? false : common.write;
+        common.name ||= stateName;
+        common.read ??= true;
+        common.write ??= false;
         if (!common.role) {
             this._logger.error(`${this.namespaceLog} Try to create state ${parentDevice ? `${parentDevice}.` : ''}${parentChannel}.${stateName} without role`);
             return;
@@ -3914,7 +3987,7 @@ export class AdapterClass extends EventEmitter {
                 common.def = max;
             }
         }
-        this.setObjectNotExists(id, {
+        const stateResult = this.setObjectNotExists(id, {
             type: 'state',
             common: common,
             native: _native,
@@ -3922,32 +3995,29 @@ export class AdapterClass extends EventEmitter {
             if (err) {
                 return tools.maybeCallbackWithError(callback, err);
             }
-            else if (common.def !== undefined) {
+            if (common.def !== undefined) {
                 this.getState(id, null, (err, state) => {
                     if (!state) {
                         if (common.defAck !== undefined) {
-                            this.setState(id, common.def, common.defAck, options, callback);
+                            return this.setState(id, common.def, common.defAck, options, callback);
                         }
-                        else {
-                            this.setState(id, common.def, options, callback);
-                        }
-                    }
-                    else {
-                        return tools.maybeCallback(callback);
+                        return this.setState(id, common.def, options, callback);
                     }
+                    return tools.maybeCallback(callback);
                 });
             }
             else {
                 this.getState(id, null, (err, state) => {
                     if (!state) {
-                        this.setState(id, null, true, options, callback);
-                    }
-                    else {
-                        return tools.maybeCallback(callback);
+                        return this.setState(id, null, true, options, callback);
                     }
+                    return tools.maybeCallback(callback);
                 });
             }
         });
+        if (stateResult instanceof Promise) {
+            stateResult.catch(e => this._logger.error(`${this.namespaceLog} Cannot create state object: ${e.message}`));
+        }
     }
     /**
      * Delete device with all its channels and states.
@@ -4005,6 +4075,16 @@ export class AdapterClass extends EventEmitter {
         }
         return tools.maybeCallback(callback);
     }
+    /**
+     * Add a channel to an enum.
+     *
+     * @param enumName the enum category (e.g. rooms, functions)
+     * @param addTo the enum id to add the channel to
+     * @param parentDevice the parent device name
+     * @param channelName the name of the channel
+     * @param options optional user context
+     * @param callback return result
+     */
     addChannelToEnum(enumName, addTo, parentDevice, channelName, options, callback) {
         if (typeof options === 'function') {
             callback = options;
@@ -4052,11 +4132,11 @@ export class AdapterClass extends EventEmitter {
                         obj.from = `system.adapter.${this.namespace}`;
                         obj.user = options?.user || SYSTEM_ADMIN_USER;
                         obj.ts = Date.now();
-                        this.#objects.setObject(obj._id, obj, options, callback);
-                    }
-                    else {
-                        return tools.maybeCallback(callback);
+                        return callback
+                            ? this.#objects.setObject(obj._id, obj, options, callback)
+                            : this.#objects.setObject(obj._id, obj, options);
                     }
+                    return tools.maybeCallback(callback);
                 }
             });
         }
@@ -4076,28 +4156,40 @@ export class AdapterClass extends EventEmitter {
                         obj.from = `system.adapter.${this.namespace}`;
                         obj.user = options?.user || SYSTEM_ADMIN_USER;
                         obj.ts = Date.now();
-                        this.#objects.setObject(obj._id, obj, options, callback);
-                    }
-                    else {
-                        return tools.maybeCallback(callback);
+                        return callback
+                            ? this.#objects.setObject(obj._id, obj, options, callback)
+                            : this.#objects.setObject(obj._id, obj, options);
                     }
+                    return tools.maybeCallback(callback);
                 }
-                else {
-                    // Create enum
-                    this.#objects.setObject(`enum.${enumName}.${addTo}`, {
-                        common: {
-                            name: addTo,
-                            members: [objId],
-                        },
+                // Create enum
+                return callback
+                    ? this.#objects.setObject(`enum.${enumName}.${addTo}`, {
+                        common: { name: addTo, members: [objId] },
                         from: `system.adapter.${this.namespace}`,
                         ts: Date.now(),
                         type: 'enum',
                         native: {},
-                    }, options, callback);
-                }
+                    }, options, callback)
+                    : this.#objects.setObject(`enum.${enumName}.${addTo}`, {
+                        common: { name: addTo, members: [objId] },
+                        from: `system.adapter.${this.namespace}`,
+                        ts: Date.now(),
+                        type: 'enum',
+                        native: {},
+                    }, options);
             });
         }
     }
+    /**
+     * Remove a channel from an enum.
+     *
+     * @param enumName the enum category (e.g. rooms, functions)
+     * @param parentDevice the parent device name
+     * @param channelName the name of the channel
+     * @param options optional user context
+     * @param callback return result
+     */
     deleteChannelFromEnum(enumName, parentDevice, channelName, options, callback) {
         if (typeof options === 'function') {
             callback = options;
@@ -4258,11 +4350,11 @@ export class AdapterClass extends EventEmitter {
         return tools.maybeCallback(callback);
     }
     /**
-     * @param parentDevice
-     * @param parentChannel
-     * @param stateName
-     * @param options
-     * @param callback
+     * @param parentDevice the parent device name
+     * @param parentChannel the parent channel name
+     * @param stateName the name of the state
+     * @param options optional user context
+     * @param callback return result
      * @deprecated use `this.delObject` instead
      */
     deleteState(parentDevice, parentChannel, stateName, options, callback) {
@@ -4346,6 +4438,12 @@ export class AdapterClass extends EventEmitter {
         const _name = this._DCS2ID(parentDevice, parentChannel, stateName);
         this.delObject(_name, options, callback);
     }
+    /**
+     * Get all devices of this adapter.
+     *
+     * @param options optional user context, or the callback
+     * @param callback return result
+     */
     getDevices(options, callback) {
         if (typeof options === 'function' && typeof callback === 'object') {
             const tmp = callback;
@@ -4384,6 +4482,13 @@ export class AdapterClass extends EventEmitter {
             return tools.maybeCallbackWithError(callback, null, res);
         });
     }
+    /**
+     * Get all channels of this adapter or of the given device.
+     *
+     * @param parentDevice the parent device name, or the callback
+     * @param options optional user context, or the callback
+     * @param callback return result
+     */
     getChannelsOf(parentDevice, options, callback) {
         if (typeof options === 'function') {
             callback = options;
@@ -4431,6 +4536,14 @@ export class AdapterClass extends EventEmitter {
             return tools.maybeCallbackWithError(options.callback, null, res);
         });
     }
+    /**
+     * Get all states of this adapter or of the given device/channel.
+     *
+     * @param parentDevice the parent device name, or the callback
+     * @param parentChannel the parent channel name, or the callback
+     * @param options optional user context, or the callback
+     * @param callback return result
+     */
     getStatesOf(parentDevice, parentChannel, options, callback) {
         if (typeof options === 'function') {
             callback = options;
@@ -4509,6 +4622,17 @@ export class AdapterClass extends EventEmitter {
             }
         });
     }
+    /**
+     * Add a state to an enum.
+     *
+     * @param enumName the enum category (e.g. rooms, functions)
+     * @param addTo the enum id to add the state to
+     * @param parentDevice the parent device name
+     * @param parentChannel the parent channel name
+     * @param stateName the name of the state
+     * @param options optional user context
+     * @param callback return result
+     */
     addStateToEnum(enumName, addTo, parentDevice, parentChannel, stateName, options, callback) {
         if (typeof options === 'function') {
             callback = options;
@@ -4568,11 +4692,11 @@ export class AdapterClass extends EventEmitter {
                     obj.from = `system.adapter.${this.namespace}`;
                     obj.user = options?.user || SYSTEM_ADMIN_USER;
                     obj.ts = Date.now();
-                    this.#objects.setObject(obj._id, obj, options, callback);
-                }
-                else {
-                    return tools.maybeCallback(callback);
+                    return callback
+                        ? this.#objects.setObject(obj._id, obj, options, callback)
+                        : this.#objects.setObject(obj._id, obj, options);
                 }
+                return tools.maybeCallback(callback);
             });
         }
         else {
@@ -4587,31 +4711,44 @@ export class AdapterClass extends EventEmitter {
                         obj.from = `system.adapter.${this.namespace}`;
                         obj.user = options?.user || SYSTEM_ADMIN_USER;
                         obj.ts = Date.now();
-                        this.#objects.setObject(obj._id, obj, callback);
-                    }
-                    else {
-                        return tools.maybeCallback(callback);
+                        return callback
+                            ? this.#objects.setObject(obj._id, obj, callback)
+                            : this.#objects.setObject(obj._id, obj);
                     }
+                    return tools.maybeCallback(callback);
                 }
-                else {
-                    if (err) {
-                        return tools.maybeCallbackWithError(callback, err);
-                    }
-                    // Create enum
-                    this.#objects.setObject(`enum.${enumName}.${addTo}`, {
-                        common: {
-                            name: addTo,
-                            members: [objId],
-                        },
+                if (err) {
+                    return tools.maybeCallbackWithError(callback, err);
+                }
+                // Create enum
+                return callback
+                    ? this.#objects.setObject(`enum.${enumName}.${addTo}`, {
+                        common: { name: addTo, members: [objId] },
                         from: `system.adapter.${this.namespace}`,
                         ts: Date.now(),
                         type: 'enum',
                         native: {},
-                    }, options, callback);
-                }
+                    }, options, callback)
+                    : this.#objects.setObject(`enum.${enumName}.${addTo}`, {
+                        common: { name: addTo, members: [objId] },
+                        from: `system.adapter.${this.namespace}`,
+                        ts: Date.now(),
+                        type: 'enum',
+                        native: {},
+                    }, options);
             });
         }
     }
+    /**
+     * Remove a state from an enum.
+     *
+     * @param enumName the enum category (e.g. rooms, functions)
+     * @param parentDevice the parent device name
+     * @param parentChannel the parent channel name
+     * @param stateName the name of the state
+     * @param options optional user context
+     * @param callback return result
+     */
     deleteStateFromEnum(enumName, parentDevice, parentChannel, stateName, options, callback) {
         if (typeof options === 'function') {
             callback = options;
@@ -4823,6 +4960,14 @@ export class AdapterClass extends EventEmitter {
         }
         this.#objects.readDir(_adapter, path, options, callback);
     }
+    /**
+     * Deletes a file in the DB.
+     *
+     * @param _adapter adapter name, or null for the current adapter
+     * @param name path to the file
+     * @param options optional user context
+     * @param callback return result
+     */
     unlink(_adapter, name, options, callback) {
         if (_adapter === null) {
             _adapter = this.name;
@@ -4843,6 +4988,15 @@ export class AdapterClass extends EventEmitter {
         }
         this.#objects.unlink(_adapter, name, options, callback);
     }
+    /**
+     * Renames a file in the DB.
+     *
+     * @param _adapter adapter name, or null for the current adapter
+     * @param oldName current path to the file
+     * @param newName new path to the file
+     * @param options optional user context
+     * @param callback return result
+     */
     rename(_adapter, oldName, newName, options, callback) {
         if (_adapter === null) {
             _adapter = this.name;
@@ -4862,8 +5016,16 @@ export class AdapterClass extends EventEmitter {
             this._logger.info(`${this.namespaceLog} rename not processed because Objects database not connected`);
             return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
         }
-        this.#objects.rename(_adapter, oldName, newName, options, callback);
+        return this.#objects.rename(_adapter, oldName, newName, options, callback);
     }
+    /**
+     * Creates a directory in the DB.
+     *
+     * @param _adapter adapter name, or null for the current adapter
+     * @param dirname path to the directory
+     * @param options optional user context
+     * @param callback return result
+     */
     mkdir(_adapter, dirname, options, callback) {
         if (_adapter === null) {
             _adapter = this.name;
@@ -5001,6 +5163,13 @@ export class AdapterClass extends EventEmitter {
             return tools.maybeCallbackWithError(callback, e);
         }
     }
+    /**
+     * Formats a numeric value using the given format string.
+     *
+     * @param value the value to format
+     * @param decimals number of decimals to keep, or the format string
+     * @param _format optional format string for the decimal and thousands separator
+     */
     formatValue(value, decimals, _format) {
         if (typeof decimals !== 'number') {
             _format = decimals;
@@ -5030,6 +5199,13 @@ export class AdapterClass extends EventEmitter {
                     // @ts-expect-error fix later
                     .replace(/\B(?=(\d{3})+(?!\d))/g, format[0]);
     }
+    /**
+     * Formats a date or duration according to the given format string.
+     *
+     * @param dateObj the date to format
+     * @param isDuration whether the value represents a duration, or the format string
+     * @param _format optional format string
+     */
     formatDate(dateObj, isDuration, _format) {
         if ((typeof isDuration === 'string' && isDuration.toLowerCase() === 'duration') || isDuration === true) {
             isDuration = true;
@@ -5201,6 +5377,7 @@ export class AdapterClass extends EventEmitter {
             message = command;
             command = 'send';
         }
+        // Legacy contract: bad arguments throw synchronously on the callback-style API.
         Validator.assertString(instanceName, 'instanceName');
         Validator.assertString(command, 'command');
         if (!tools.isObject(callback)) {
@@ -5209,13 +5386,42 @@ export class AdapterClass extends EventEmitter {
         if (options !== undefined) {
             Validator.assertObject(options, 'options');
         }
-        return this._sendTo({
-            instanceName,
-            command,
-            message,
-            options,
-            callback: callback,
-        });
+        if (tools.isObject(callback)) {
+            this.#fireAndForget(this.#async.sendTo(instanceName, command, message, this.#withSendFlags(options, { callback: callback })), 'Error in sendTo');
+            return;
+        }
+        const cb = callback;
+        if (typeof cb === 'function') {
+            this.sendToAsync(instanceName, command, message, options).then((reply) => cb(reply), (err) => cb(err));
+            return;
+        }
+        this.#fireAndForget(this.#async.sendTo(instanceName, command, message, this.#withSendFlags(options, { expectReply: false })), 'Error in sendTo');
+    }
+    /**
+     * Merges send-control flags into the caller-supplied options for delegation to the async facade.
+     * A non-object `options` is forwarded unchanged so the facade's validation surfaces it.
+     *
+     * @param options caller-supplied send options (unvalidated)
+     * @param flags control flags to apply
+     * @param flags.expectReply when false, the facade sends fire-and-forget
+     * @param flags.callback legacy callback-info header to attach to the message
+     */
+    #withSendFlags(options, flags) {
+        if (options !== undefined && !tools.isObject(options)) {
+            return options;
+        }
+        return { ...options, ...flags };
+    }
+    /**
+     * Observes a fire-and-forget promise from the callback-compat layer, logging any rejection without
+     * rethrowing. Used only where the legacy callback API had no channel to surface the error; async
+     * callers on {@link AsyncAdapter} instead await and catch.
+     *
+     * @param promise the promise to observe
+     * @param errorMessage log prefix describing the failed action
+     */
+    #fireAndForget(promise, errorMessage) {
+        promise.catch((e) => this._logger.error(`${this.namespaceLog} ${errorMessage}: ${e instanceof Error ? e.message : String(e)}`));
     }
     /**
      * Async version of sendTo
@@ -5227,124 +5433,16 @@ export class AdapterClass extends EventEmitter {
      * @param options optional options to define a timeout. This allows to get an error callback if no answer received in time (only if target is specific instance)
      */
     sendToAsync(instanceName, command, message, options) {
-        return new Promise((resolve, reject) => {
-            const callback = resOrError => {
-                if (resOrError instanceof Error) {
-                    reject(resOrError);
-                }
-                resolve(resOrError);
-            };
-            // validation takes place inside sendTo so skip here
-            this.sendTo(instanceName, command, message, callback, options);
-        });
-    }
-    async _sendTo(_options) {
-        const { command, message, callback, options } = _options;
-        let { instanceName } = _options;
-        const obj = {
-            command,
-            message,
-            from: `system.adapter.${this.namespace}`,
-        };
-        if (!instanceName) {
-            // @ts-expect-error TODO it could also be the cb object
-            return tools.maybeCallbackWithError(callback, 'No instanceName provided or not a string');
-        }
-        if (!instanceName.startsWith('system.adapter.')) {
-            instanceName = `system.adapter.${instanceName}`;
-        }
-        if (!this.#states) {
-            // if states is no longer existing, we do not need to unsubscribe
-            this._logger.info(`${this.namespaceLog} sendTo not processed because States database not connected`);
-            // @ts-expect-error TODO it could also be the cb object
-            return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
-        }
-        if (typeof message !== 'object') {
-            this._logger.silly(`${this.namespaceLog} sendTo "${command}" to ${instanceName} from system.adapter.${this.namespace}: ${message}`);
-        }
-        else {
-            this._logger.silly(`${this.namespaceLog} sendTo "${command}" to ${instanceName} from system.adapter.${this.namespace}`);
-        }
-        // If not specific instance
-        if (!instanceName.match(/\.[0-9]+$/)) {
-            if (!this.#objects) {
-                this._logger.info(`${this.namespaceLog} sendTo not processed because Objects database not connected`);
-                // @ts-expect-error TODO it could also be the cb object
-                return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
-            }
-            try {
-                // Send it to all instances of adapter
-                const res = await this.#objects.getObjectView('system', 'instance', {
-                    startkey: `${instanceName}.`,
-                    endkey: `${instanceName}.\u9999`,
-                });
-                if (res) {
-                    for (const row of res.rows) {
-                        try {
-                            await this.#states.pushMessage(row.id, obj);
-                        }
-                        catch (e) {
-                            // @ts-expect-error TODO it could also be the cb object
-                            return tools.maybeCallbackWithError(callback, e);
-                        }
-                    }
-                }
-            }
-            catch {
-                //ignore
-            }
+        if (typeof message === 'function') {
+            options = undefined;
+            message = command;
+            command = 'send';
         }
-        else {
-            if (callback) {
-                if (typeof callback === 'function') {
-                    // force subscribe even no messagebox enabled
-                    if (!isMessageboxSupported(this.common) && !this.mboxSubscribed) {
-                        this.mboxSubscribed = true;
-                        this.#states.subscribeMessage(`system.adapter.${this.namespace}`);
-                    }
-                    obj.callback = {
-                        message,
-                        id: this._callbackId++,
-                        ack: false,
-                        time: Date.now(),
-                    };
-                    if (this._callbackId >= 0xffffffff) {
-                        this._callbackId = 1;
-                    }
-                    const callbackId = obj.callback.id;
-                    let timer;
-                    if (options?.timeout) {
-                        timer = setTimeout(() => {
-                            const callbackObj = this.messageCallbacks.get(callbackId);
-                            if (callbackObj) {
-                                callbackObj.cb(new Error('Timeout exceeded'));
-                                this.messageCallbacks.delete(callbackId);
-                            }
-                        }, options.timeout);
-                    }
-                    this.messageCallbacks.set(callbackId, { cb: callback, time: Date.now(), timer });
-                    // delete too old callbacks IDs
-                    const now = Date.now();
-                    for (const [_id, cb] of this.messageCallbacks) {
-                        if (now - cb.time > 3_600_000) {
-                            this.messageCallbacks.delete(_id);
-                        }
-                    }
-                }
-                else {
-                    // callback is an object
-                    obj.callback = callback;
-                    obj.callback.ack = true;
-                }
-            }
-            try {
-                await this.#states.pushMessage(instanceName, obj);
-            }
-            catch (e) {
-                // @ts-expect-error TODO it could also be the cb object
-                return tools.maybeCallbackWithError(callback, e);
-            }
+        else if (typeof message === 'undefined') {
+            message = command;
+            command = 'send';
         }
+        return this.#async.sendTo(instanceName, command, message, this.#withSendFlags(options, { expectReply: true }));
     }
     /**
      * Send message to specific host or to all hosts.
@@ -5364,10 +5462,15 @@ export class AdapterClass extends EventEmitter {
      *        ```
      */
     sendToHost(hostName, command, message, callback) {
+        if (typeof message === 'function' && typeof callback === 'undefined') {
+            callback = message;
+            message = undefined;
+        }
         if (typeof message === 'undefined') {
             message = command;
             command = 'send';
         }
+        // Legacy contract: bad arguments throw synchronously on the callback-style API.
         if (hostName !== null) {
             Validator.assertString(hostName, 'hostName');
         }
@@ -5375,91 +5478,34 @@ export class AdapterClass extends EventEmitter {
         if (!tools.isObject(callback)) {
             Validator.assertOptionalCallback(callback, 'callback');
         }
-        return this._sendToHost({
-            hostName,
-            command,
-            message,
-            callback: callback,
-        });
-    }
-    async _sendToHost(_options) {
-        const { command, message, callback } = _options;
-        let { hostName } = _options;
-        const obj = { command, message, from: `system.adapter.${this.namespace}` };
-        if (!this.#states) {
-            // if states is no longer existing, we do not need to unsubscribe
-            this._logger.info(`${this.namespaceLog} sendToHost not processed because States database not connected`);
-            // @ts-expect-error TODO it could also be the cb object
-            return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
-        }
-        if (hostName && !hostName.startsWith('system.host.')) {
-            hostName = `system.host.${hostName}`;
+        if (tools.isObject(callback)) {
+            this.#fireAndForget(this.#async.sendToHost(hostName, command, message, {
+                callback: callback,
+            }), 'Error in sendToHost');
+            return;
         }
-        if (!hostName) {
-            if (!this.#objects) {
-                this._logger.info(`${this.namespaceLog} sendToHost not processed because Objects database not connected`);
-                // @ts-expect-error TODO it could also be the cb object
-                return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
-            }
-            // Send to all hosts
-            this.#objects.getObjectList({
-                startkey: 'system.host.',
-                endkey: `system.host.\u9999`,
-            }, null, async (err, res) => {
-                if (!this.#states) {
-                    // if states is no longer existing, we do not need to unsubscribe
-                    return;
-                }
-                if (!err && res?.rows.length) {
-                    for (const row of res.rows) {
-                        const parts = row.id.split('.');
-                        // ignore system.host.name.alive and so on
-                        if (parts.length === 3) {
-                            try {
-                                await this.#states.pushMessage(row.id, obj);
-                            }
-                            catch (e) {
-                                // @ts-expect-error TODO it could also be the cb object
-                                return tools.maybeCallbackWithError(callback, e);
-                            }
-                        }
-                    }
-                }
-            });
+        const cb = callback;
+        // A broadcast (hostName === null) yields many replies, so the callback is ignored — matching legacy behavior.
+        if (typeof cb === 'function' && hostName !== null) {
+            this.sendToHostAsync(hostName, command, message).then((reply) => cb(reply), (err) => cb(err));
+            return;
         }
-        else {
-            if (callback) {
-                if (typeof callback === 'function') {
-                    // force subscribe even no messagebox enabled
-                    if (!isMessageboxSupported(this.common) && !this.mboxSubscribed) {
-                        this.mboxSubscribed = true;
-                        this.#states.subscribeMessage(`system.adapter.${this.namespace}`);
-                    }
-                    obj.callback = {
-                        message,
-                        id: this._callbackId++,
-                        ack: false,
-                        time: Date.now(),
-                    };
-                    if (this._callbackId >= 0xffffffff) {
-                        this._callbackId = 1;
-                    }
-                    this.messageCallbacks.set(obj.callback.id, { cb: callback, time: Date.now() });
-                }
-                else {
-                    // callback is an object
-                    obj.callback = callback;
-                    obj.callback.ack = true;
-                }
-            }
-            try {
-                await this.#states.pushMessage(hostName, obj);
-            }
-            catch (e) {
-                // @ts-expect-error TODO it could also be the cb object
-                return tools.maybeCallbackWithError(callback, e);
-            }
+        this.#fireAndForget(this.#async.sendToHost(hostName, command, message, { expectReply: false }), 'Error in sendToHost');
+    }
+    /**
+     * Async version of sendToHost
+     *
+     * @param hostName name of the host where the message must be sent to. E.g. "myPC" or "system.host.myPC". If argument is null, the message will be sent to all hosts.
+     * @param command command name. One of: "cmdExec", "getRepository", "getInstalled", "getVersion", "getDiagData", "getLocationOnDisk", "getDevList", "getLogs", "delLogs", "readDirAsZip", "writeDirAsZip", "readObjectsAsZip", "writeObjectsAsZip", "checkLogging". Commands can be checked in controller.js (function processMessage)
+     * @param message object that will be given as argument for request
+     */
+    sendToHostAsync(hostName, command, message) {
+        if (typeof message === 'undefined') {
+            message = command;
+            command = 'send';
         }
+        // broadcast (null host) yields many responses → never wait for a reply
+        return this.#async.sendToHost(hostName, command, message, { expectReply: hostName !== null });
     }
     /**
      * Send a message to an active UI Client
@@ -5467,22 +5513,7 @@ export class AdapterClass extends EventEmitter {
      * @param options clientId and data options
      */
     sendToUI(options) {
-        if (!this.#states) {
-            throw new Error(tools.ERRORS.ERROR_DB_CLOSED);
-        }
-        const { clientId, data } = options;
-        if (clientId === undefined) {
-            return this.uiMessagingController.sendToAllClients({
-                data,
-                states: this.#states,
-            });
-        }
-        Validator.assertString(clientId, 'clientId');
-        return this.uiMessagingController.sendToClient({
-            clientId,
-            data,
-            states: this.#states,
-        });
+        return this.#async.sendToUI(options);
     }
     /**
      * Send notification with given scope and category to host of this adapter
@@ -5493,31 +5524,80 @@ export class AdapterClass extends EventEmitter {
      * @param options - Additional options for the notification, currently `contextData` is supported
      */
     async registerNotification(scope, category, message, options) {
-        if (!this.#states) {
-            // if states is no longer existing, we do not need to set
-            this._logger.info(`${this.namespaceLog} registerNotification not processed because States database not connected`);
-            throw new Error(tools.ERRORS.ERROR_DB_CLOSED);
-        }
-        Validator.assertString(scope, 'scope');
-        if (category !== null) {
-            Validator.assertString(category, 'category');
-        }
-        Validator.assertString(message, 'message');
-        if (options !== undefined) {
-            Validator.assertObject(options, 'options');
-        }
-        const obj = {
-            command: 'addNotification',
-            message: {
-                scope,
-                category,
-                message,
-                instance: this.namespace,
-                contextData: options?.contextData,
-            },
-            from: `system.adapter.${this.namespace}`,
-        };
-        await this.#states.pushMessage(`system.host.${this.host}`, obj);
+        return this.#async.registerNotification(scope, category, message, options);
+    }
+    /**
+     * Register an exclusive resource (serial port, TCP/UDP port, USB device, ...) as used by this instance.
+     *
+     * Exclusive resources are the ones that cannot be occupied by more than one instance at the same time.
+     * The information is forwarded to the host this instance runs on and stored under
+     * `system.host.<hostname>.usedResources.<type>`, so the user gets an overview of the occupied resources
+     * and can pick a free one when configuring a new instance.
+     *
+     * Registering is **additive**: call it once per occupied resource, in any order and from any number of
+     * async init paths. The host drops what this instance registered before whenever the instance starts, so
+     * a stale registration from a previous configuration cannot survive a restart.
+     *
+     * @param type the kind of resource, e.g. "serialPort" or "tcpPort"
+     * @param data the strictly typed payload describing the resource, e.g. `{ port: '/dev/ttyUSB0' }`
+     * @throws {Error} when the host refuses the registration - e.g. because `common.declareUsedResources` is not `true` - or does not answer
+     */
+    async registerUsedResource(type, data) {
+        return this.#async.registerUsedResource(type, data);
+    }
+    /**
+     * Ask whether another instance on this host currently holds an exclusive resource, without
+     * registering anything.
+     *
+     * Call this **before** opening the port or the device - afterwards the operating system has
+     * already decided the conflict and this can only improve the error message.
+     *
+     * The answer is a hint, not a permission: the registry knows what adapters declare, so an empty
+     * result does not promise the resource is free.
+     *
+     * @param type the kind of resource, e.g. "serialPort" or "tcpPort"
+     * @param data description of the resource that is about to be used, e.g. `{ port: 1883 }`
+     * @returns the entries of other instances that currently hold it, newest registration first
+     * @throws {Error} when the host refuses the request or does not answer
+     */
+    async checkUsedResource(type, data) {
+        return this.#async.checkUsedResource(type, data);
+    }
+    /**
+     * Free all exclusive resources this instance registered, across all types.
+     *
+     * This is not needed on start-up (the host already resets the registrations of a starting instance) nor
+     * on shutdown (the host marks them as no longer held). Use it when the instance drops everything it
+     * occupied while it keeps running, e.g. on a reconfiguration.
+     *
+     * @throws {Error} when the host refuses the command or does not answer
+     */
+    async clearUsedResources() {
+        return this.#async.clearUsedResources();
+    }
+    /**
+     * Free previously registered exclusive resources of this instance.
+     *
+     * `data` is a **filter, not the exact payload**: every field it names must match, fields it does not name
+     * are ignored. `freeUsedResource('tcpPort', { port: 8080 })` therefore also frees an entry registered as
+     * `{ port: 8080, bind: '0.0.0.0' }`, and if `data` is omitted, all registered resources of the given
+     * `type` for this instance are freed. The change is forwarded to the host this instance runs on and
+     * reflected in `system.host.<hostname>.usedResources.<type>`; a filter that matches nothing is logged by
+     * the host.
+     *
+     * @param type the kind of resource, e.g. "serialPort" or "tcpPort"
+     * @param data the fields identifying the resources to free; if omitted, all resources of `type` are freed
+     * @throws {Error} when the host refuses the command or does not answer
+     */
+    async freeUsedResource(type, data) {
+        return this.#async.freeUsedResource(type, data);
+    }
+    /**
+     * @param type resource type to read; if omitted, the resources of every type are returned
+     * @returns the list of registered resources (across all instances of this host)
+     */
+    async getHostUsedResources(type) {
+        return type === undefined ? this.#async.getHostUsedResources() : this.#async.getHostUsedResources(type);
     }
     /**
      * Writes value into states DB.
@@ -5736,7 +5816,7 @@ export class AdapterClass extends EventEmitter {
             // ignore
         }
         if (!userAcl) {
-            // User does not exists
+            // User does not exist
             this._logger.error(`${this.namespaceLog} unknown user "${options.user}"`);
             return options;
         }
@@ -5758,8 +5838,7 @@ export class AdapterClass extends EventEmitter {
         // read all groups for this user
         this.users[options.user] = {
             groups: options.groups,
-            // @ts-expect-error TODO: UserCommon has no acl
-            acl: userAcl.common?.acl || {},
+            acl: {},
         };
         await this._getGroups(options.groups);
         // combine all rights
@@ -5770,9 +5849,9 @@ export class AdapterClass extends EventEmitter {
             }
             const group = this.groups[gName];
             if (group.common?.acl?.file) {
-                if (!user.acl || !user.acl.file) {
-                    user.acl = user.acl || {};
-                    user.acl.file = user.acl.file || {};
+                if (!user.acl?.file) {
+                    user.acl ||= {};
+                    user.acl.file ||= {};
                     user.acl.file.create = group.common.acl.file.create;
                     user.acl.file.read = group.common.acl.file.read;
                     user.acl.file.write = group.common.acl.file.write;
@@ -5780,17 +5859,17 @@ export class AdapterClass extends EventEmitter {
                     user.acl.file.list = group.common.acl.file.list;
                 }
                 else {
-                    user.acl.file.create = user.acl.file.create || group.common.acl.file.create;
-                    user.acl.file.read = user.acl.file.read || group.common.acl.file.read;
-                    user.acl.file.write = user.acl.file.write || group.common.acl.file.write;
-                    user.acl.file.delete = user.acl.file.delete || group.common.acl.file.delete;
-                    user.acl.file.list = user.acl.file.list || group.common.acl.file.list;
+                    user.acl.file.create ||= group.common.acl.file.create;
+                    user.acl.file.read ||= group.common.acl.file.read;
+                    user.acl.file.write ||= group.common.acl.file.write;
+                    user.acl.file.delete ||= group.common.acl.file.delete;
+                    user.acl.file.list ||= group.common.acl.file.list;
                 }
             }
             if (group.common?.acl?.object) {
                 if (!user.acl || !user.acl.object) {
-                    user.acl = user.acl || {};
-                    user.acl.object = user.acl.object || {};
+                    user.acl ||= {};
+                    user.acl.object ||= {};
                     user.acl.object.create = group.common.acl.object.create;
                     user.acl.object.read = group.common.acl.object.read;
                     user.acl.object.write = group.common.acl.object.write;
@@ -5798,17 +5877,17 @@ export class AdapterClass extends EventEmitter {
                     user.acl.object.list = group.common.acl.object.list;
                 }
                 else {
-                    user.acl.object.create = user.acl.object.create || group.common.acl.object.create;
-                    user.acl.object.read = user.acl.object.read || group.common.acl.object.read;
-                    user.acl.object.write = user.acl.object.write || group.common.acl.object.write;
-                    user.acl.object.delete = user.acl.object.delete || group.common.acl.object.delete;
-                    user.acl.object.list = user.acl.object.list || group.common.acl.object.list;
+                    user.acl.object.create ||= group.common.acl.object.create;
+                    user.acl.object.read ||= group.common.acl.object.read;
+                    user.acl.object.write ||= group.common.acl.object.write;
+                    user.acl.object.delete ||= group.common.acl.object.delete;
+                    user.acl.object.list ||= group.common.acl.object.list;
                 }
             }
             if (group.common?.acl?.users) {
                 if (!user.acl || !user.acl.users) {
-                    user.acl = user.acl || {};
-                    user.acl.users = user.acl.users || {};
+                    user.acl ||= {};
+                    user.acl.users ||= {};
                     user.acl.users.create = group.common.acl.users.create;
                     user.acl.users.read = group.common.acl.users.read;
                     user.acl.users.write = group.common.acl.users.write;
@@ -5816,17 +5895,17 @@ export class AdapterClass extends EventEmitter {
                     user.acl.users.list = group.common.acl.users.list;
                 }
                 else {
-                    user.acl.users.create = user.acl.users.create || group.common.acl.users.create;
-                    user.acl.users.read = user.acl.users.read || group.common.acl.users.read;
-                    user.acl.users.write = user.acl.users.write || group.common.acl.users.write;
-                    user.acl.users.delete = user.acl.users.delete || group.common.acl.users.delete;
-                    user.acl.users.list = user.acl.users.list || group.common.acl.users.list;
+                    user.acl.users.create ||= group.common.acl.users.create;
+                    user.acl.users.read ||= group.common.acl.users.read;
+                    user.acl.users.write ||= group.common.acl.users.write;
+                    user.acl.users.delete ||= group.common.acl.users.delete;
+                    user.acl.users.list ||= group.common.acl.users.list;
                 }
             }
             if (group.common?.acl?.state) {
                 if (!user.acl || !user.acl.state) {
-                    user.acl = user.acl || {};
-                    user.acl.state = user.acl.state || {};
+                    user.acl ||= {};
+                    user.acl.state ||= {};
                     user.acl.state.create = group.common.acl.state.create;
                     user.acl.state.read = group.common.acl.state.read;
                     user.acl.state.write = group.common.acl.state.write;
@@ -5834,11 +5913,11 @@ export class AdapterClass extends EventEmitter {
                     user.acl.state.list = group.common.acl.state.list;
                 }
                 else {
-                    user.acl.state.create = user.acl.state.create || group.common.acl.state.create;
-                    user.acl.state.read = user.acl.state.read || group.common.acl.state.read;
-                    user.acl.state.write = user.acl.state.write || group.common.acl.state.write;
-                    user.acl.state.delete = user.acl.state.delete || group.common.acl.state.delete;
-                    user.acl.state.list = user.acl.state.list || group.common.acl.state.list;
+                    user.acl.state.create ||= group.common.acl.state.create;
+                    user.acl.state.read ||= group.common.acl.state.read;
+                    user.acl.state.write ||= group.common.acl.state.write;
+                    user.acl.state.delete ||= group.common.acl.state.delete;
+                    user.acl.state.list ||= group.common.acl.state.list;
                 }
             }
         }
@@ -5846,10 +5925,18 @@ export class AdapterClass extends EventEmitter {
         return options;
     }
     _checkState(obj, options, command) {
+        // Members of the administrator group are not restricted by the ACL of a state, the same as for objects and files
+        if (options.groups?.includes(SYSTEM_ADMIN_GROUP)) {
+            return true;
+        }
         const limitToOwnerRights = options.limitToOwnerRights === true;
         if (obj?.acl) {
-            obj.acl.state = obj.acl.state || obj.acl.object;
+            obj.acl.state ||= obj.acl.object;
             if (obj.acl.state) {
+                if (!options.acl) {
+                    this._logger.warn(`${this.namespaceLog} Permission error for user "${options.user} on "${obj._id}": ${command}`);
+                    return false;
+                }
                 // If user is owner
                 if (options.user === obj.acl.owner) {
                     if (command === 'setState' || command === 'delState') {
@@ -5876,7 +5963,7 @@ export class AdapterClass extends EventEmitter {
                         this._logger.warn(`${this.namespaceLog} Called unknown command on "${obj._id}": ${command}`);
                     }
                 }
-                else if (options.groups.includes(obj.acl.ownerGroup) && !limitToOwnerRights) {
+                else if (options.groups?.includes(obj.acl.ownerGroup) && !limitToOwnerRights) {
                     if (command === 'setState' || command === 'delState') {
                         if (command === 'delState' && !options.acl.state.delete) {
                             this._logger.warn(`${this.namespaceLog} Permission error for user "${options.user} on "${obj._id}": ${command}`);
@@ -6166,7 +6253,6 @@ export class AdapterClass extends EventEmitter {
             return tools.maybeCallbackWithError(callback, null, res.id, res.notChanged);
         }
         const res = await this._setStateChangedHelper(fixedId, stateObj);
-        // @ts-expect-error todo fix it
         return tools.maybeCallbackWithError(callback, null, res.id, res.notChanged);
     }
     /**
@@ -6252,7 +6338,9 @@ export class AdapterClass extends EventEmitter {
         }
         // if state.from provided, we use it else, we set default property
         state.from =
-            typeof state.from === 'string' && state.from !== '' ? state.from : `system.adapter.${this.namespace}`;
+            typeof state.from === 'string' && state.from !== ''
+                ? state.from
+                : `system.adapter.${this.namespace}`;
         state.user = options?.user || SYSTEM_ADMIN_USER;
         if (!id || typeof id !== 'string') {
             const warn = id ? `ID can be only string and not "${typeof id}"` : `Empty ID: ${JSON.stringify(state)}`;
@@ -6260,10 +6348,12 @@ export class AdapterClass extends EventEmitter {
             return tools.maybeCallbackWithError(callback, warn);
         }
         id = this.fixForbiddenCharsInId(id);
-        if (options?.user && options.user !== SYSTEM_ADMIN_USER) {
+        if (options?.user &&
+            options.user !== SYSTEM_ADMIN_USER) {
             let obj;
             try {
-                obj = (await this._checkStates(id, options, 'setState')).objs[0];
+                obj = (await this._checkStates(id, options, 'setState'))
+                    .objs[0];
             }
             catch (e) {
                 return tools.maybeCallbackWithError(callback, e);
@@ -6311,8 +6401,8 @@ export class AdapterClass extends EventEmitter {
                     this.outputCount++;
                     this.#states.setState(aliasId, tools.formatAliasValue({
                         sourceCommon: obj?.common,
-                        targetCommon: targetObj && targetObj.common,
-                        state,
+                        targetCommon: targetObj?.common,
+                        state: state,
                         logger: this._logger,
                         logNamespace: this.namespaceLog,
                         sourceId: obj?._id,
@@ -6375,7 +6465,7 @@ export class AdapterClass extends EventEmitter {
                     this.#states.setState(targetId, tools.formatAliasValue({
                         sourceCommon: obj.common,
                         targetCommon: targetObj?.common,
-                        state,
+                        state: state,
                         logger: this._logger,
                         logNamespace: this.namespaceLog,
                         sourceId: obj._id,
@@ -6475,7 +6565,8 @@ export class AdapterClass extends EventEmitter {
             // wrap non-object values in a state object
             state = state !== undefined ? { val: state } : {};
         }
-        if (state.val === undefined && !Object.keys(state).length) {
+        if (state.val === undefined &&
+            !Object.keys(state).length) {
             // undefined is not allowed as state.val -> return
             this._logger.info(`${this.namespaceLog} undefined is not a valid state value for id "${id}"`);
             // TODO: reactivate line below + test in in next controller version (02.05.2021)
@@ -6486,10 +6577,14 @@ export class AdapterClass extends EventEmitter {
         }
         // if state.from provided, we use it else, we set default property
         state.from =
-            typeof state.from === 'string' && state.from !== '' ? state.from : `system.adapter.${this.namespace}`;
-        state.user = options?.user || SYSTEM_ADMIN_USER;
+            typeof state.from === 'string' && state.from !== ''
+                ? state.from
+                : `system.adapter.${this.namespace}`;
+        state.user =
+            options?.user || SYSTEM_ADMIN_USER;
         id = this.fixForbiddenCharsInId(id);
-        if (options?.user && options.user !== SYSTEM_ADMIN_USER) {
+        if (options?.user &&
+            options.user !== SYSTEM_ADMIN_USER) {
             try {
                 await this._checkStates(id, options, 'setState');
             }
@@ -6517,7 +6612,7 @@ export class AdapterClass extends EventEmitter {
      *            }
      *        ```
      *
-     *        See possible attributes of the state in @setState explanation
+     *        See possible attributes of the state in `setState` explanation
      */
     getState(id, options, callback) {
         // we use any types here, because validation takes place in foreign method
@@ -6542,7 +6637,7 @@ export class AdapterClass extends EventEmitter {
      *            }
      *        ```
      *
-     *        See possible attributes of the state in @setState explanation
+     *        See possible attributes of the state in `setState` explanation
      */
     getForeignState(id, options, callback) {
         if (typeof options === 'function') {
@@ -6646,7 +6741,7 @@ export class AdapterClass extends EventEmitter {
             if (this.oStates && this.oStates[id]) {
                 return tools.maybeCallbackWithError(callback, null, this.oStates[id]);
             }
-            return this.#states.getState(id, callback);
+            return callback ? this.#states.getState(id, callback) : this.#states.getState(id);
         }
     }
     // find out default history instance
@@ -6731,7 +6826,7 @@ export class AdapterClass extends EventEmitter {
      *            }
      *        ```
      *
-     *        See possible attributes of the state in @setState explanation
+     *        See possible attributes of the state in `setState` explanation
      */
     getHistory(id, options, callback) {
         if (typeof options === 'function') {
@@ -6753,13 +6848,12 @@ export class AdapterClass extends EventEmitter {
             this._utils.validateId(id, true, null);
         }
         catch (e) {
-            // @ts-expect-error
             return tools.maybeCallbackWithError(callback, e);
         }
-        options = options || {};
-        options.end = options.end || Date.now() + 5000000;
+        options ||= {};
+        options.end ||= Date.now() + 5000000;
         if (!options.count && !options.start) {
-            options.start = options.start || Date.now() - 604800000; // - 1 week
+            options.start ||= Date.now() - 604800000; // - 1 week
         }
         if (!options.instance) {
             if (!this.defaultHistory) {
@@ -6774,12 +6868,10 @@ export class AdapterClass extends EventEmitter {
                 await this._checkStates(id, options, 'getState');
             }
             catch (e) {
-                // @ts-expect-error
                 return tools.maybeCallbackWithError(callback, e);
             }
         }
-        this.sendTo(options.instance || 'history.0', 'getHistory', { id, options }, res => {
-            // @ts-expect-error
+        this.sendTo(options.instance || 'history.0', 'getHistory', { id, options }, (res) => {
             tools.maybeCallbackWithError(callback, res.error, res.result, res.step, res.sessionId);
         });
     }
@@ -6806,7 +6898,7 @@ export class AdapterClass extends EventEmitter {
     }
     /**
      * Deletes a state of this instance.
-     * The object will NOT be deleted. If you want to delete it too, use @delObject instead.
+     * The object will NOT be deleted. If you want to delete it too, use `delObject` instead.
      *
      * It is not required to provice the adapter namespace, because it will automatically be added.
      * E.g. to delete "adapterName.X.myObject", only "myObject" is required as ID.
@@ -6849,7 +6941,7 @@ export class AdapterClass extends EventEmitter {
     }
     /**
      * Deletes a state of any adapter.
-     * The object is NOT deleted. If you want to delete it too, use @delForeignObject instead.
+     * The object is NOT deleted. If you want to delete it too, use `delForeignObject` instead.
      *
      * No error is returned if state does not exist.
      *
@@ -6893,7 +6985,12 @@ export class AdapterClass extends EventEmitter {
                 return tools.maybeCallbackWithError(callback, e);
             }
         }
-        await this.#states.delState(id, callback);
+        if (callback) {
+            this.#states.delState(id, callback);
+        }
+        else {
+            await this.#states.delState(id);
+        }
     }
     /**
      * Read all states of this adapter, that pass the pattern
@@ -6928,7 +7025,7 @@ export class AdapterClass extends EventEmitter {
         const arr = await this.#states.getStates(keys);
         const result = {};
         for (let i = 0; i < keys.length; i++) {
-            const obj = targetObjs && targetObjs[i];
+            const obj = targetObjs?.[i];
             if (obj?.common?.alias && srcObjs) {
                 const srcObj = srcObjs[i];
                 if (srcObj) {
@@ -7041,12 +7138,12 @@ export class AdapterClass extends EventEmitter {
     async _getForeignStates(_options) {
         const { options, pattern, callback } = _options;
         if (!this.#states) {
-            // if states is no longer existing, we do not need to unsubscribe
+            // if states are no longer existing, we do not need to unsubscribe
             this._logger.info(`${this.namespaceLog} getForeignStates not processed because States database not connected`);
             return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
         }
         if (!this.#objects) {
-            // if states is no longer existing, we do not need to unsubscribe
+            // if states are no longer existing, we do not need to unsubscribe
             this._logger.info(`${this.namespaceLog} getForeignStates not processed because Objects database not connected`);
             return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
         }
@@ -7063,7 +7160,7 @@ export class AdapterClass extends EventEmitter {
                 }
             }
             else {
-                const res = await this._processStates(pattern, options?._objects);
+                const res = await this._processStates(pattern, options._objects);
                 return tools.maybeCallbackWithError(callback, null, res);
             }
         }
@@ -7131,90 +7228,6 @@ export class AdapterClass extends EventEmitter {
             }
         }
     }
-    /**
-     * Add subscription for given alias, if it is not a state it will be ignored
-     *
-     * @param aliasObj the alias object
-     * @param pattern pattern to subscribe for
-     */
-    async _addAliasSubscribe(aliasObj, pattern) {
-        if (aliasObj.type !== 'state') {
-            // no state types do not need to be subscribed
-            return;
-        }
-        if (!aliasObj.common?.alias?.id) {
-            // if state and no id given
-            this._logger.warn(`${this.namespaceLog} Alias ${aliasObj._id} has no target 5`);
-            throw new Error(`Alias ${aliasObj._id} has no target`);
-        }
-        // id can be string or can have attribute read
-        const sourceId = tools.isObject(aliasObj.common.alias.id)
-            ? aliasObj.common.alias.id.read
-            : aliasObj.common.alias.id;
-        // validate here because we use objects/states db directly
-        try {
-            this._utils.validateId(sourceId, true, null);
-        }
-        catch (e) {
-            throw new Error(`Error validating alias id of ${aliasObj._id}: ${e.message}`);
-        }
-        const targetEntry = {
-            alias: deepClone(aliasObj.common.alias),
-            id: aliasObj._id,
-            pattern,
-            type: aliasObj.common.type,
-            max: aliasObj.common.max,
-            min: aliasObj.common.min,
-            unit: aliasObj.common.unit,
-        };
-        let aliasDetails;
-        if (!this.aliases.has(sourceId)) {
-            aliasDetails = { targets: [] };
-            // add the alias before doing anything async, so if a delete comes in between we can detect it
-            this.aliases.set(sourceId, aliasDetails);
-        }
-        else {
-            aliasDetails = this.aliases.get(sourceId);
-        }
-        if (!aliasDetails.source) {
-            await this.#states.subscribe(sourceId);
-            // we ignore permissions on the source object and thus get it as admin user
-            const sourceObj = await this.#objects.getObject(sourceId, { user: SYSTEM_ADMIN_USER });
-            // if we have a common and the alias has not been removed in-between
-            if (sourceObj?.common && this.aliases.has(sourceObj._id)) {
-                aliasDetails.source = {
-                    min: sourceObj.common.min,
-                    max: sourceObj.common.max,
-                    type: sourceObj.common.type,
-                    unit: sourceObj.common.unit,
-                };
-            }
-        }
-        // add the alias target after we have ensured that we have the source set
-        aliasDetails.targets.push(targetEntry);
-    }
-    /**
-     * Remove an alias subscribe
-     *
-     * @param sourceId id of the source object
-     * @param aliasObjOrIdx the alias target or the index of the targets array
-     */
-    async _removeAliasSubscribe(sourceId, aliasObjOrIdx) {
-        if (!this.aliases.has(sourceId)) {
-            return;
-        }
-        const alias = this.aliases.get(sourceId);
-        // remove from targets array
-        const pos = typeof aliasObjOrIdx === 'number' ? aliasObjOrIdx : alias.targets.indexOf(aliasObjOrIdx);
-        if (pos !== -1) {
-            alias.targets.splice(pos, 1);
-            // unsubscribe if no more aliases exists
-            if (!alias.targets.length) {
-                this.aliases.delete(sourceId);
-                await this.#states.unsubscribe(sourceId);
-            }
-        }
-    }
     /**
      * Subscribe for changes on all states of all adapters (and system states), that pass the pattern
      *
@@ -7241,167 +7254,10 @@ export class AdapterClass extends EventEmitter {
             Validator.assertObject(options, 'options');
         }
         Validator.assertPattern(pattern, 'pattern');
-        return this._subscribeForeignStates({ pattern, options, callback });
-    }
-    async _subscribeForeignStates(_options) {
-        const { pattern, options, callback } = _options;
-        // Todo check rights for options
-        await this._autoSubscribeOn();
-        if (!this.#states) {
-            // if states is no longer existing, we do not need to unsubscribe
-            this._logger.info(`${this.namespaceLog} subscribeForeignStates not processed because States database not connected`);
-            return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
-        }
-        if (!this.#objects) {
-            this._logger.info(`${this.namespaceLog} subscribeForeignStates not processed because Objects database not connected`);
-            return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
-        }
-        // compare if this pattern for one of auto-subscribe adapters
-        for (const autoSubEntry of this.autoSubscribe) {
-            if (typeof pattern === 'string' && (pattern === '*' || pattern.startsWith(`${autoSubEntry}.`))) {
-                // put this pattern into adapter list
-                let state;
-                try {
-                    state = await this.#states.getState(`system.adapter.${autoSubEntry}.subscribes`);
-                }
-                catch {
-                    // ignore
-                }
-                state = state || { val: '{}' };
-                state.val = state.val || '{}';
-                let subs;
-                try {
-                    subs = JSON.parse(state.val);
-                }
-                catch {
-                    this._logger.error(`${this.namespaceLog} Cannot parse subscribes for "${autoSubEntry}.subscribes"`);
-                }
-                // validate that correct structure read from state.val
-                if (!tools.isObject(subs)) {
-                    subs = {};
-                }
-                if (!tools.isObject(subs[pattern])) {
-                    subs[pattern] = {};
-                }
-                if (typeof subs[pattern][this.namespace] !== 'number') {
-                    subs[pattern][this.namespace] = 0;
-                }
-                subs[pattern][this.namespace]++;
-                this.outputCount++;
-                await this.#states.setState(`system.adapter.${autoSubEntry}.subscribes`, JSON.stringify(subs));
-            }
-        }
-        if (Array.isArray(pattern)) {
-            // get all aliases
-            const aliasesIds = pattern
-                .map(id => (id.startsWith(ALIAS_STARTS_WITH) ? id : null))
-                .filter(id => id);
-            // get all non aliases
-            const nonAliasesIds = pattern
-                .map(id => (!id.startsWith(ALIAS_STARTS_WITH) ? id : null))
-                .filter(id => id);
-            for (const aliasPattern of pattern) {
-                if ((aliasPattern.startsWith(ALIAS_STARTS_WITH) || aliasPattern.includes('*')) &&
-                    !this.aliasPatterns.has(aliasPattern)) {
-                    // it's a new alias conform pattern to store
-                    this.aliasPatterns.add(aliasPattern);
-                }
-            }
-            const promises = [];
-            if (aliasesIds.length) {
-                if (!this._aliasObjectsSubscribed) {
-                    this._aliasObjectsSubscribed = true;
-                    this.#objects.subscribe(`${ALIAS_STARTS_WITH}*`);
-                }
-                const aliasObjs = await this._getObjectsByArray(aliasesIds, options);
-                for (const aliasObj of aliasObjs) {
-                    if (aliasObj) {
-                        promises.push(this._addAliasSubscribe(aliasObj, aliasObj._id));
-                    }
-                }
-            }
-            if (nonAliasesIds.length) {
-                for (const id of nonAliasesIds) {
-                    promises.push(new Promise(resolve => this.#states.subscribeUser(id, resolve)));
-                }
-            }
-            try {
-                await Promise.all(promises);
-            }
-            catch (e) {
-                this._logger.error(`${this.namespaceLog} Error on "subscribeForeignStates": ${e.message}`);
-            }
-            return tools.maybeCallback(callback);
-        }
-        else if (pattern.includes('*')) {
-            if (pattern === '*' || pattern.startsWith(ALIAS_STARTS_WITH)) {
-                if (!this._aliasObjectsSubscribed) {
-                    this._aliasObjectsSubscribed = true;
-                    this.#objects.subscribe(`${ALIAS_STARTS_WITH}*`);
-                }
-                // read all aliases
-                try {
-                    // @ts-expect-error adjust types
-                    const objs = await this.getForeignObjectsAsync(pattern, null, null, options);
-                    const promises = [];
-                    if (!this.aliasPatterns.has(pattern)) {
-                        // it's a new pattern to store
-                        this.aliasPatterns.add(pattern);
-                    }
-                    for (const id of Object.keys(objs)) {
-                        // If alias
-                        if (id.startsWith(ALIAS_STARTS_WITH)) {
-                            const aliasObj = objs[id];
-                            promises.push(this._addAliasSubscribe(aliasObj, pattern));
-                        }
-                    }
-                    try {
-                        await Promise.all(promises);
-                    }
-                    catch (e) {
-                        this._logger.error(`${this.namespaceLog} Error on "subscribeForeignStates": ${e.message}`);
-                    }
-                    if (!this.#states) {
-                        // if states is no longer existing, we do not need to unsubscribe
-                        this._logger.info(`${this.namespaceLog} subscribeForeignStates not processed because States database not connected`);
-                        return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
-                    }
-                    if (promises.length && pattern !== '*') {
-                        return tools.maybeCallback(callback);
-                    }
-                    // no alias objects found or pattern *
-                    this.#states.subscribeUser(pattern, callback);
-                }
-                catch (e) {
-                    this._logger.warn(`${this.namespaceLog} Cannot subscribe to ${pattern}: ${e.message}`);
-                    return tools.maybeCallbackWithError(callback, e);
-                }
-            }
-            else {
-                this.#states.subscribeUser(pattern, callback);
-            }
-        }
-        else if (pattern.startsWith(ALIAS_STARTS_WITH)) {
-            if (!this._aliasObjectsSubscribed) {
-                this._aliasObjectsSubscribed = true;
-                this.#objects.subscribe(`${ALIAS_STARTS_WITH}*`);
-            }
-            // just read one alias Object
-            try {
-                const aliasObj = await this.#objects.getObject(pattern, options);
-                if (aliasObj) {
-                    await this._addAliasSubscribe(aliasObj, pattern);
-                    return tools.maybeCallback(callback);
-                }
-                return tools.maybeCallback(callback);
-            }
-            catch (e) {
-                this._logger.warn(`${this.namespaceLog} cannot subscribe on alias "${pattern}": ${e.message}`);
-            }
-        }
-        else {
-            this.#states.subscribeUser(pattern, callback);
-        }
+        const cb = callback;
+        this.#subscriptions
+            .subscribeForeignStates(pattern, options)
+            .then(() => cb?.(), (err) => cb?.(err));
     }
     /**
      * Unsubscribe for changes for given pattern
@@ -7435,102 +7291,10 @@ export class AdapterClass extends EventEmitter {
         if (options !== null && options !== undefined) {
             Validator.assertObject(options, 'options');
         }
-        return this._unsubscribeForeignStates({ pattern, options, callback });
-    }
-    async _unsubscribeForeignStates(_options) {
-        const { pattern, callback } = _options;
-        if (!this.#states) {
-            // if states is no longer existing, we do not need to unsubscribe
-            this._logger.info(`${this.namespaceLog} unsubscrubeForeignStates not processed because States database not connected`);
-            return tools.maybeCallbackWithError(callback, tools.ERRORS.ERROR_DB_CLOSED);
-        }
-        if (this.autoSubscribe && typeof pattern === 'string') {
-            for (const autoSub of this.autoSubscribe) {
-                if (pattern === '*' || pattern.substring(0, autoSub.length + 1) === `${autoSub}.`) {
-                    // remove this pattern from adapter list
-                    let state;
-                    try {
-                        state = await this.#states.getState(`system.adapter.${autoSub}.subscribes`);
-                    }
-                    catch {
-                        // ignore
-                    }
-                    if (!state || !state.val) {
-                        continue;
-                    }
-                    let subs;
-                    try {
-                        subs = JSON.parse(state.val);
-                    }
-                    catch {
-                        this._logger.error(`${this.namespaceLog} Cannot parse subscribes for "${autoSub}.subscribes"`);
-                        continue;
-                    }
-                    if (!tools.isObject(subs) ||
-                        !tools.isObject(subs[pattern]) ||
-                        subs[pattern][this.namespace] === undefined) {
-                        // check subs is a valid object, because it comes from state.val
-                        continue;
-                    }
-                    if (typeof subs[pattern][this.namespace] === 'number') {
-                        subs[pattern][this.namespace]--;
-                        if (subs[pattern][this.namespace] <= 0) {
-                            delete subs[pattern][this.namespace];
-                        }
-                    }
-                    else {
-                        // corrupted info, we can only delete
-                        delete subs[pattern][this.namespace];
-                    }
-                    // if no other subs are there
-                    if (!Object.keys(subs[pattern]).length) {
-                        delete subs[pattern];
-                    }
-                    this.outputCount++;
-                    await this.#states.setState(`system.adapter.${autoSub}.subscribes`, JSON.stringify(subs));
-                }
-            }
-        }
-        let aliasPattern;
-        const promises = [];
-        if (Array.isArray(pattern)) {
-            // process every entry as single unsubscribe
-            for (const _pattern of pattern) {
-                promises.push(this.unsubscribeForeignStatesAsync(_pattern));
-            }
-        }
-        else if (pattern.includes('*') || pattern.startsWith(ALIAS_STARTS_WITH)) {
-            if (pattern === '*' || pattern.startsWith(ALIAS_STARTS_WITH)) {
-                aliasPattern = pattern; // check all aliases
-                if (pattern === '*') {
-                    promises.push(this.#states.unsubscribeUser(pattern));
-                }
-            }
-            else {
-                promises.push(this.#states.unsubscribeUser(pattern));
-            }
-        }
-        else {
-            promises.push(this.#states.unsubscribeUser(pattern));
-        }
-        if (aliasPattern) {
-            // if pattern known, remove it from alias patterns to not subscribe to further matching aliases
-            this.aliasPatterns.delete(aliasPattern);
-            for (const [sourceId, alias] of this.aliases) {
-                for (let i = alias.targets.length - 1; i >= 0; i--) {
-                    if (alias.targets[i].pattern === aliasPattern) {
-                        promises.push(this._removeAliasSubscribe(sourceId, i));
-                    }
-                }
-            }
-        }
-        await Promise.all(promises);
-        // if no alias subscribed any longer, remove subscription
-        if (!this.aliases.size && this._aliasObjectsSubscribed) {
-            this._aliasObjectsSubscribed = false;
-            this.#objects.unsubscribe(`${ALIAS_STARTS_WITH}*`);
-        }
-        return tools.maybeCallback(callback);
+        const cb = callback;
+        this.#subscriptions
+            .unsubscribeForeignStates(pattern, options)
+            .then(() => cb?.(), (err) => cb?.(err));
     }
     /**
      * Subscribe for changes on all states of this instance, that pass the pattern
@@ -7554,11 +7318,10 @@ export class AdapterClass extends EventEmitter {
         if (options !== null && options !== undefined) {
             Validator.assertObject(options, 'options');
         }
-        return this._subscribeForeignStates({
-            pattern: Array.isArray(pattern) ? pattern : this._utils.fixId(pattern, true),
-            options,
-            callback,
-        });
+        const cb = callback;
+        this.#subscriptions
+            .subscribeForeignStates(Array.isArray(pattern) ? pattern : this._utils.fixId(pattern, true), options)
+            .then(() => cb?.(), (err) => cb?.(err));
     }
     /**
      * Unsubscribe for changes for given pattern for own states.
@@ -7584,11 +7347,10 @@ export class AdapterClass extends EventEmitter {
         if (options !== null && options !== undefined) {
             Validator.assertObject(options, 'options');
         }
-        return this._unsubscribeForeignStates({
-            pattern: Array.isArray(pattern) ? pattern : this._utils.fixId(pattern, true),
-            options,
-            callback,
-        });
+        const cb = callback;
+        this.#subscriptions
+            .unsubscribeForeignStates(Array.isArray(pattern) ? pattern : this._utils.fixId(pattern, true), options)
+            .then(() => cb?.(), (err) => cb?.(err));
     }
     /**
      * Return plugin instance
@@ -7616,31 +7378,6 @@ export class AdapterClass extends EventEmitter {
         Validator.assertString(name, 'name');
         return this.pluginHandler.getPluginConfig(name);
     }
-    async _autoSubscribeOn() {
-        if (!this.autoSubscribe && this.#objects) {
-            try {
-                // collect all
-                const res = await this.#objects.getObjectViewAsync('system', 'instance', {
-                    startkey: 'system.adapter.',
-                    endkey: 'system.adapter.\u9999',
-                });
-                this.autoSubscribe = [];
-                for (const row of res.rows) {
-                    if (row.value?.common.subscribable) {
-                        const _id = row.id.substring(15); // cut system.adapter.
-                        if (!this.autoSubscribe.includes(_id)) {
-                            this.autoSubscribe.push(_id);
-                        }
-                    }
-                }
-                // because of autoSubscribe
-                await this.#objects.subscribeAsync('system.adapter.*');
-            }
-            catch {
-                // ignore
-            }
-        }
-    }
     /**
      * This method returns the list of license that can be used by this adapter
      *
@@ -7769,20 +7506,24 @@ export class AdapterClass extends EventEmitter {
         /** Time after which states regularly set by the status report expire in seconds */
         const reportStatusExpirySec = Math.floor(this._config.system.statisticsInterval / 1_000) + 10;
         const id = `system.adapter.${this.namespace}`;
-        this.#states.setState(`${id}.alive`, {
+        this.#states
+            .setState(`${id}.alive`, {
             val: true,
             ack: true,
             expire: reportStatusExpirySec,
             from: id,
-        });
+        })
+            .catch(e => this._logger.error(`${this.namespaceLog} Cannot set alive state: ${e.message}`));
         this.outputCount++;
         if (this.connected) {
-            this.#states.setState(`${id}.connected`, {
+            this.#states
+                .setState(`${id}.connected`, {
                 val: true,
                 ack: true,
                 expire: reportStatusExpirySec,
                 from: id,
-            });
+            })
+                .catch(e => this._logger.error(`${this.namespaceLog} Cannot set connected state: ${e.message}`));
             this.outputCount++;
         }
         if (!this.startedInCompactMode) {
@@ -7797,47 +7538,59 @@ export class AdapterClass extends EventEmitter {
             //   timestamp: 864000000  // ms since epoch
             // }
             pidUsage(process.pid, (err, stats) => {
-                // sometimes adapter is stopped, but this is still running
-                if (!err && this && this.#states && this.#states.setState && stats) {
-                    this.#states.setState(`${id}.cpu`, {
+                // sometimes adapter is stopped, but this callback is still running: once
+                // terminating, the states DB connection may already be closing — skip the write to
+                // avoid a "Connection is closed" warning (setState does a read-before-write).
+                if (!err && this && this.#states && this.#states.setState && stats && !this.terminated) {
+                    this.#states
+                        .setState(`${id}.cpu`, {
                         ack: true,
                         from: id,
                         val: Math.round(100 * stats.cpu) / 100,
                         expire: reportStatusExpirySec,
-                    });
-                    this.#states.setState(`${id}.cputime`, {
+                    })
+                        .catch(e => this._logger.error(`${this.namespaceLog} Cannot set cpu state: ${e.message}`));
+                    this.#states
+                        .setState(`${id}.cputime`, {
                         ack: true,
                         from: id,
                         val: stats.ctime / 1_000,
                         expire: reportStatusExpirySec,
-                    });
+                    })
+                        .catch(e => this._logger.error(`${this.namespaceLog} Cannot set cputime state: ${e.message}`));
                     this.outputCount += 2;
                 }
             });
             try {
                 //RSS is the resident set size, the portion of the process's memory held in RAM (as opposed to the swap space or the part held in the filesystem).
                 const mem = process.memoryUsage();
-                this.#states.setState(`${id}.memRss`, {
+                this.#states
+                    .setState(`${id}.memRss`, {
                     val: parseFloat((mem.rss / 1048576) /* 1MB */
                         .toFixed(2)),
                     ack: true,
                     from: id,
                     expire: reportStatusExpirySec,
-                });
-                this.#states.setState(`${id}.memHeapTotal`, {
+                })
+                    .catch(e => this._logger.error(`${this.namespaceLog} Cannot set memRss state: ${e.message}`));
+                this.#states
+                    .setState(`${id}.memHeapTotal`, {
                     val: parseFloat((mem.heapTotal / 1048576) /* 1MB */
                         .toFixed(2)),
                     ack: true,
                     from: id,
                     expire: reportStatusExpirySec,
-                });
-                this.#states.setState(`${id}.memHeapUsed`, {
+                })
+                    .catch(e => this._logger.error(`${this.namespaceLog} Cannot set memHeapTotal state: ${e.message}`));
+                this.#states
+                    .setState(`${id}.memHeapUsed`, {
                     val: parseFloat((mem.heapUsed / 1048576) /* 1MB */
                         .toFixed(2)),
                     ack: true,
                     from: id,
                     expire: reportStatusExpirySec,
-                });
+                })
+                    .catch(e => this._logger.error(`${this.namespaceLog} Cannot set memHeapUsed state: ${e.message}`));
             }
             catch (e) {
                 this._logger.warn(`${this.namespaceLog} Could not query used process memory: ${e.message}`);
@@ -7845,35 +7598,43 @@ export class AdapterClass extends EventEmitter {
             this.outputCount += 3;
             if (this.eventLoopLags.length) {
                 const eventLoopLag = Math.ceil(this.eventLoopLags.reduce((a, b) => a + b) / this.eventLoopLags.length);
-                this.#states.setState(`${id}.eventLoopLag`, {
+                this.#states
+                    .setState(`${id}.eventLoopLag`, {
                     val: eventLoopLag,
                     ack: true,
                     from: id,
                     expire: reportStatusExpirySec,
-                }); // average of measured values
+                }) // average of measured values
+                    .catch(e => this._logger.error(`${this.namespaceLog} Cannot set eventLoopLag state: ${e.message}`));
                 this.eventLoopLags = [];
                 this.outputCount++;
             }
         }
         this.outputCount += 3;
-        this.#states.setState(`${id}.uptime`, {
+        this.#states
+            .setState(`${id}.uptime`, {
             val: parseInt(process.uptime().toFixed(), 10),
             ack: true,
             from: id,
             expire: reportStatusExpirySec,
-        });
-        this.#states.setState(`${id}.inputCount`, {
+        })
+            .catch(e => this._logger.error(`${this.namespaceLog} Cannot set uptime state: ${e.message}`));
+        this.#states
+            .setState(`${id}.inputCount`, {
             val: this.inputCount,
             ack: true,
             from: id,
             expire: reportStatusExpirySec,
-        });
-        this.#states.setState(`${id}.outputCount`, {
+        })
+            .catch(e => this._logger.error(`${this.namespaceLog} Cannot set inputCount state: ${e.message}`));
+        this.#states
+            .setState(`${id}.outputCount`, {
             val: this.outputCount,
             ack: true,
             from: id,
             expire: reportStatusExpirySec,
-        });
+        })
+            .catch(e => this._logger.error(`${this.namespaceLog} Cannot set outputCount state: ${e.message}`));
         this.inputCount = 0;
         this.outputCount = 0;
     }
@@ -7960,7 +7721,9 @@ export class AdapterClass extends EventEmitter {
             else if (this.#states?.pushLog) {
                 // Send it to all adapters, that required logs
                 for (const instanceId of this.logList) {
-                    this.#states.pushLog(instanceId, info);
+                    this.#states
+                        .pushLog(instanceId, info)
+                        .catch(e => this._logger.error(`${this.namespaceLog} Cannot push log: ${e.message}`));
                 }
             }
         });
@@ -7986,7 +7749,9 @@ export class AdapterClass extends EventEmitter {
                 if (this.logList.size && messages?.length && this.#states) {
                     for (const message of messages) {
                         for (const instanceId of this.logList) {
-                            this.#states.pushLog(instanceId, message);
+                            this.#states
+                                .pushLog(instanceId, message)
+                                .catch(e => this._logger.error(`${this.namespaceLog} Cannot push log: ${e.message}`));
                         }
                     }
                 }
@@ -8056,7 +7821,9 @@ export class AdapterClass extends EventEmitter {
                     this.emit('log', msg);
                 }
             };
-            this.#states.subscribeLog(`system.adapter.${this.namespace}`);
+            this.#states
+                .subscribeLog(`system.adapter.${this.namespace}`)
+                .catch(e => this._logger.error(`${this.namespaceLog} Cannot subscribe to log: ${e.message}`));
         }
         else {
             this.requireLog = isActive => {
@@ -8100,13 +7867,19 @@ export class AdapterClass extends EventEmitter {
                 }
                 if (!this._config.isInstall) {
                     // Subscribe for process exit signal
-                    this.#states.subscribe(`system.adapter.${this.namespace}.sigKill`);
+                    this.#states
+                        .subscribe(`system.adapter.${this.namespace}.sigKill`)
+                        .catch(e => this._logger.error(`${this.namespaceLog} Cannot subscribe to sigKill: ${e.message}`));
                     // Subscribe for loglevel
-                    this.#states.subscribe(`system.adapter.${this.namespace}.logLevel`);
+                    this.#states
+                        .subscribe(`system.adapter.${this.namespace}.logLevel`)
+                        .catch(e => this._logger.error(`${this.namespaceLog} Cannot subscribe to logLevel: ${e.message}`));
                 }
                 if (this._options.subscribable) {
                     // subscribe on if other instance wants to have states of this adapter
-                    this.#states.subscribe(`system.adapter.${this.namespace}.subscribes`);
+                    this.#states
+                        .subscribe(`system.adapter.${this.namespace}.subscribes`)
+                        .catch(e => this._logger.error(`${this.namespaceLog} Cannot subscribe to subscribes: ${e.message}`));
                     // read actual autosubscribe requests
                     let state;
                     try {
@@ -8160,7 +7933,7 @@ export class AdapterClass extends EventEmitter {
                                 isScheduled: false,
                                 exitCode: EXIT_CODES.ADAPTER_REQUESTED_TERMINATION,
                                 updateAliveState: false,
-                            });
+                            }).catch(e => this._logger.error(`${this.namespaceLog} Cannot stop adapter: ${e.message}`));
                         }
                     }
                 }
@@ -8171,14 +7944,11 @@ export class AdapterClass extends EventEmitter {
                         if (state.val && state.val !== currentLevel && isLogLevel(newLogLevel)) {
                             this.overwriteLogLevel = true;
                             this._config.log.level = newLogLevel;
-                            for (const transport in this._logger.transports) {
-                                if (!Object.prototype.hasOwnProperty.call(this._logger.transports, transport)) {
-                                    continue;
-                                }
+                            for (const transport of this._logger.transports) {
                                 // set the loglevel on transport only if no loglevel was pinned in log config
                                 // @ts-expect-error it is our own modification
-                                if (!this._logger.transports[transport]._defaultConfigLoglevel) {
-                                    this._logger.transports[transport].level = newLogLevel;
+                                if (!transport._defaultConfigLoglevel) {
+                                    transport.level = newLogLevel;
                                 }
                             }
                             this._logger.info(`${this.namespaceLog} Loglevel changed from "${currentLevel}" to "${state.val}"`);
@@ -8189,11 +7959,13 @@ export class AdapterClass extends EventEmitter {
                         }
                         this.outputCount++;
                         this.#states &&
-                            this.#states.setState(`system.adapter.${this.namespace}.logLevel`, {
+                            this.#states
+                                .setState(`system.adapter.${this.namespace}.logLevel`, {
                                 val: currentLevel,
                                 ack: true,
                                 from: `system.adapter.${this.namespace}`,
-                            });
+                            })
+                                .catch(e => this._logger.error(`${this.namespaceLog} Cannot set logLevel state: ${e.message}`));
                     }
                 }
                 // todo remove it as an error with log will be found
@@ -8236,29 +8008,7 @@ export class AdapterClass extends EventEmitter {
                     // If this is messagebox
                     const obj = state;
                     if (obj) {
-                        let callbackObj;
-                        if (obj.callback?.id) {
-                            callbackObj = this.messageCallbacks.get(obj.callback.id);
-                        }
-                        // If callback stored for this request
-                        if (obj.callback?.ack && obj.callback.id && callbackObj) {
-                            // Call callback function
-                            if (typeof callbackObj.cb === 'function') {
-                                callbackObj.cb(obj.message);
-                                if (callbackObj.timer) {
-                                    clearTimeout(callbackObj.timer);
-                                }
-                                this.messageCallbacks.delete(obj.callback.id);
-                            }
-                            // delete too old callbacks IDs, like garbage collector
-                            const now = Date.now();
-                            for (const [_id, callback] of this.messageCallbacks) {
-                                if (now - callback.time > 3_600_000) {
-                                    this.messageCallbacks.delete(_id);
-                                }
-                            }
-                        }
-                        else if (!this._stopInProgress) {
+                        if (!this.#async.resolveReply(obj) && !this._stopInProgress) {
                             if (obj.command === 'clientSubscribe') {
                                 const res = await this.uiMessagingController.registerClientSubscribeByMessage(obj);
                                 this.sendTo(obj.from, obj.command, res, obj.callback);
@@ -8269,7 +8019,7 @@ export class AdapterClass extends EventEmitter {
                             }
                             if (this._options.message) {
                                 // Else inform about a new message the adapter
-                                this._options.message(obj);
+                                Promise.resolve(this._options.message(obj)).catch(e => this._logger.error(`${this.namespaceLog} Error in message handler: ${e.message}`));
                             }
                             this.emit('message', obj);
                         }
@@ -8304,37 +8054,13 @@ export class AdapterClass extends EventEmitter {
                         }
                     }
                 }
-                else if (!this._stopInProgress && this.adapterReady && this.aliases.has(id)) {
-                    // If adapter is ready and for this ID exist some alias links
-                    const alias = this.aliases.get(id);
-                    /** Prevent multiple publishes if multiple patterns contain this alias id */
-                    const uniqueTargets = new Set();
-                    for (const target of alias.targets) {
-                        const targetId = target.id;
-                        if (uniqueTargets.has(targetId)) {
-                            continue;
+                else if (!this._stopInProgress && this.adapterReady && this.#alias.hasSource(id)) {
+                    for (const { targetId, state: aState } of this.#alias.resolveSourceChange(id, state)) {
+                        if (typeof this._options.stateChange === 'function') {
+                            Promise.resolve(this._options.stateChange(targetId, aState)).catch(e => this._logger.error(`${this.namespaceLog} Error in stateChange handler: ${e.message}`));
                         }
-                        uniqueTargets.add(targetId);
-                        const source = alias.source;
-                        const aState = state
-                            ? tools.formatAliasValue({
-                                sourceCommon: source,
-                                targetCommon: target,
-                                state: deepClone(state),
-                                logger: this._logger,
-                                logNamespace: this.namespaceLog,
-                                sourceId: id,
-                                targetId,
-                            })
-                            : null;
-                        if (aState || !state) {
-                            if (typeof this._options.stateChange === 'function') {
-                                this._options.stateChange(targetId, aState);
-                            }
-                            else {
-                                // emit 'stateChange' event instantly
-                                setImmediate(() => this.emit('stateChange', targetId, aState));
-                            }
+                        else {
+                            setImmediate(() => this.emit('stateChange', targetId, aState));
                         }
                     }
                 }
@@ -8373,7 +8099,7 @@ export class AdapterClass extends EventEmitter {
                             return;
                         } // If reconnected in the meantime, do not terminate
                         this._logger.warn(`${this.namespaceLog} Cannot connect/reconnect to states DB. Stopping adapter.`);
-                        this._stop({ exitCode: EXIT_CODES.NO_ERROR, updateAliveState: false });
+                        this._stop({ exitCode: EXIT_CODES.NO_ERROR, updateAliveState: false }).catch(e => this._logger.error(`${this.namespaceLog} Cannot stop adapter: ${e.message}`));
                     }, 5000);
             },
         });
@@ -8440,7 +8166,7 @@ export class AdapterClass extends EventEmitter {
                             return;
                         } // If reconnected in the meantime, do not terminate
                         this._logger.warn(`${this.namespaceLog} Cannot connect/reconnect to objects DB. Stopping adapter.`);
-                        this._stop({ exitCode: EXIT_CODES.NO_ERROR, updateAliveState: false });
+                        this._stop({ exitCode: EXIT_CODES.NO_ERROR, updateAliveState: false }).catch(e => this._logger.error(`${this.namespaceLog} Cannot stop adapter: ${e.message}`));
                     }, 4000);
             },
             change: async (id, obj) => {
@@ -8452,7 +8178,14 @@ export class AdapterClass extends EventEmitter {
                 // If desired, that adapter must be terminated
                 if (id === `system.adapter.${this.namespace}` && obj?.common?.enabled === false) {
                     this._logger.info(`${this.namespaceLog} Adapter is disabled => stop`);
-                    this._stop();
+                    this._stop().catch(e => this._logger.error(`${this.namespaceLog} Cannot stop adapter: ${e.message}`));
+                    return;
+                }
+                // a certificate we are using has been changed => restart to reload it
+                if (id === CERTIFICATES_OBJECT_ID) {
+                    if (this.#async.hasRelevantCertificateChange(obj)) {
+                        this.#scheduleCertificateRestart('Changed certificate detected');
+                    }
                     return;
                 }
                 // update language, dateFormat and comma
@@ -8468,78 +8201,17 @@ export class AdapterClass extends EventEmitter {
                 }
                 // if alias
                 if (id.startsWith(ALIAS_STARTS_WITH)) {
-                    // if `this.aliases` is empty, or no target found, it's a new alias
-                    let isNewAlias = true;
-                    for (const [sourceId, alias] of this.aliases) {
-                        const targetAlias = alias.targets.find(entry => entry.id === id);
-                        // Find entry for this alias
-                        if (targetAlias) {
-                            isNewAlias = false;
-                            // new sourceId or same
-                            if (obj?.common?.alias?.id) {
-                                // check if id.read or id
-                                const newSourceId = typeof obj.common.alias.id.read === 'string'
-                                    ? obj.common.alias.id.read
-                                    : obj.common.alias.id;
-                                // if linked ID changed
-                                if (newSourceId !== sourceId) {
-                                    await this._removeAliasSubscribe(sourceId, targetAlias);
-                                    try {
-                                        await this._addAliasSubscribe(obj, targetAlias.pattern);
-                                    }
-                                    catch (e) {
-                                        this._logger.error(`${this.namespaceLog} Could not add alias subscription: ${e.message}`);
-                                    }
-                                }
-                                else {
-                                    // update attributes
-                                    targetAlias.min = obj.common.min;
-                                    targetAlias.max = obj.common.max;
-                                    targetAlias.type = obj.common.type;
-                                    targetAlias.alias = deepClone(obj.common.alias);
-                                }
-                            }
-                            else {
-                                // link was deleted
-                                // remove from targets array
-                                await this._removeAliasSubscribe(sourceId, targetAlias);
-                            }
-                        }
-                    }
-                    // it's a new alias, we add it to our subscription
-                    if (isNewAlias && obj) {
-                        for (const aliasPattern of this.aliasPatterns) {
-                            // check if it's in our subs range, if so add it
-                            const testPattern = aliasPattern.slice(-1) === '*'
-                                ? new RegExp(tools.pattern2RegEx(aliasPattern))
-                                : aliasPattern;
-                            if ((typeof testPattern === 'string' && aliasPattern === id) ||
-                                (testPattern instanceof RegExp && testPattern.test(id))) {
-                                try {
-                                    await this._addAliasSubscribe(obj, id);
-                                }
-                                catch (e) {
-                                    this._logger.warn(`${this.namespaceLog} Could not add alias subscription: ${e.message}`);
-                                }
-                                break;
-                            }
-                        }
-                    }
+                    await this.#alias.handleAliasObjectChange(id, obj);
                 }
                 // process auto-subscribe adapters
                 if (id.startsWith('system.adapter.')) {
                     if (obj?.common?.subscribable) {
                         const _id = id.substring(15); // 'system.adapter.'.length
                         if (obj.common.enabled) {
-                            if (!this.autoSubscribe.includes(_id)) {
-                                this.autoSubscribe.push(_id);
-                            }
+                            this.#subscriptions.addSubscribableInstance(_id);
                         }
                         else {
-                            const pos = this.autoSubscribe.indexOf(_id);
-                            if (pos !== -1) {
-                                this.autoSubscribe.splice(pos, 1);
-                            }
+                            this.#subscriptions.removeSubscribableInstance(_id);
                         }
                     }
                 }
@@ -8677,7 +8349,9 @@ export class AdapterClass extends EventEmitter {
             // if adapterState was destroyed, we should not continue
             return;
         }
-        this.#states.subscribe(`system.adapter.${this.namespace}.plugins.*`);
+        this.#states
+            .subscribe(`system.adapter.${this.namespace}.plugins.*`)
+            .catch(e => this._logger.error(`${this.namespaceLog} Cannot subscribe to plugins: ${e.message}`));
         if (this._options.instance === undefined) {
             if (!adapterConfig || !('common' in adapterConfig) || !adapterConfig.common.enabled) {
                 if (adapterConfig && 'common' in adapterConfig && adapterConfig.common.enabled !== undefined) {
@@ -8769,7 +8443,9 @@ export class AdapterClass extends EventEmitter {
                 this.stop = params => this._stop({ ...params, isPause: false });
             }
             // Monitor logging state
-            this.#states.subscribe(`${SYSTEM_ADAPTER_PREFIX}*.logging`);
+            this.#states
+                .subscribe(`${SYSTEM_ADAPTER_PREFIX}*.logging`)
+                .catch(e => this._logger.error(`${this.namespaceLog} Cannot subscribe to logging: ${e.message}`));
             if (typeof this._options.message === 'function' &&
                 // @ts-expect-error, we should infer correctly that this is an InstanceObject in this case
                 !isMessageboxSupported(adapterConfig.common)) {
@@ -8777,8 +8453,9 @@ export class AdapterClass extends EventEmitter {
                 // @ts-expect-error we should infer adapterConfig correctly
             }
             else if (isMessageboxSupported(adapterConfig.common)) {
-                this.mboxSubscribed = true;
-                this.#states.subscribeMessage(`system.adapter.${this.namespace}`);
+                this.#states
+                    .subscribeMessage(`system.adapter.${this.namespace}`)
+                    .catch(e => this._logger.error(`${this.namespaceLog} Cannot subscribe to messages: ${e.message}`));
             }
         }
         else {
@@ -8795,7 +8472,7 @@ export class AdapterClass extends EventEmitter {
             this.host = this.common?.host || tools.getHostName();
         }
         this.adapterConfig = adapterConfig;
-        this._utils = new Validator(this.#objects, this.#states, this.namespaceLog, this._logger, this.namespace, this._namespaceRegExp);
+        this._utils = new Validator(this.#objects, this.namespaceLog, this._logger, this.namespace, this._namespaceRegExp);
         this.log = new Log(this.namespaceLog, this._config.log.level, this._logger);
         await this._createInstancesObjects(adapterConfig);
         // auto oObjects
@@ -8804,19 +8481,22 @@ export class AdapterClass extends EventEmitter {
             await this.subscribeObjectsAsync('*');
         }
         // initialize the system secret
-        await this.getSystemSecret();
+        const secret = await this.getSystemSecret();
         // Decrypt all attributes of encryptedNative
-        const promises = [];
         // @ts-expect-error
         if (Array.isArray(adapterConfig.encryptedNative)) {
+            this._decryptedNativeAttributes = new Array();
             // @ts-expect-error
             for (const attr of adapterConfig.encryptedNative) {
-                // we can only decrypt strings
-                // @ts-expect-error
-                if (typeof this.config[attr] === 'string') {
-                    promises.push(this.getEncryptedConfig(attr)
-                        .then(decryptedValue => setObjectAttribute(this.config, attr, decryptedValue))
-                        .catch(e => this._logger.error(`${this.namespaceLog} Can not decrypt attribute ${attr}: ${e.message}`)));
+                // one attribute at a time, so a value that cannot be decrypted does not stop the others
+                try {
+                    decryptArray({ obj: this.config, secret, keys: [attr] });
+                    // only after it worked: a failed decrypt leaves the encrypted value in place, and
+                    // reading it back must decrypt it rather than hand out the cipher text
+                    this._decryptedNativeAttributes.push(attr);
+                }
+                catch (e) {
+                    this._logger.error(`${this.namespaceLog} Can not decrypt attribute ${attr}: ${e.message}`);
                 }
             }
         }
@@ -8827,19 +8507,19 @@ export class AdapterClass extends EventEmitter {
                 this.SUPPORTED_FEATURES.splice(idx, 1);
             }
         }
-        // Wait till all attributes decrypted
-        await Promise.all(promises);
         if (!this.#states) {
             // if this.adapterStates was destroyed, we should not continue
             return;
         }
         this.outputCount++;
         // set current loglevel
-        this.#states.setState(`system.adapter.${this.namespace}.logLevel`, {
+        this.#states
+            .setState(`system.adapter.${this.namespace}.logLevel`, {
             val: this._config.log.level,
             ack: true,
             from: `system.adapter.${this.namespace}`,
-        });
+        })
+            .catch(e => this._logger.error(`${this.namespaceLog} Cannot set logLevel state: ${e.message}`));
         try {
             await this.#checkObjectsWarnLimit();
         }
@@ -8864,19 +8544,24 @@ export class AdapterClass extends EventEmitter {
                 this._reportInterval = setInterval(() => this._reportStatus(), this._config.system.statisticsInterval);
                 this._reportStatus();
                 const id = `system.adapter.${this.namespace}`;
-                this.#states.setState(`${id}.compactMode`, {
+                this.#states
+                    .setState(`${id}.compactMode`, {
                     ack: true,
                     from: id,
                     val: !!this.startedInCompactMode,
-                });
+                })
+                    .catch(e => this._logger.error(`${this.namespaceLog} Cannot set compactMode state: ${e.message}`));
                 this.outputCount++;
                 if (this.startedInCompactMode) {
-                    this.#states.setState(`${id}.cpu`, { ack: true, from: id, val: 0 });
-                    this.#states.setState(`${id}.cputime`, { ack: true, from: id, val: 0 });
-                    this.#states.setState(`${id}.memRss`, { val: 0, ack: true, from: id });
-                    this.#states.setState(`${id}.memHeapTotal`, { val: 0, ack: true, from: id });
-                    this.#states.setState(`${id}.memHeapUsed`, { val: 0, ack: true, from: id });
-                    this.#states.setState(`${id}.eventLoopLag`, { val: 0, ack: true, from: id });
+                    const onErr = (e) => {
+                        this._logger.error(`${this.namespaceLog} Cannot reset compact metric: ${e.message}`);
+                    };
+                    this.#states.setState(`${id}.cpu`, { ack: true, from: id, val: 0 }).catch(onErr);
+                    this.#states.setState(`${id}.cputime`, { ack: true, from: id, val: 0 }).catch(onErr);
+                    this.#states.setState(`${id}.memRss`, { val: 0, ack: true, from: id }).catch(onErr);
+                    this.#states.setState(`${id}.memHeapTotal`, { val: 0, ack: true, from: id }).catch(onErr);
+                    this.#states.setState(`${id}.memHeapUsed`, { val: 0, ack: true, from: id }).catch(onErr);
+                    this.#states.setState(`${id}.eventLoopLag`, { val: 0, ack: true, from: id }).catch(onErr);
                     this.outputCount += 6;
                 }
                 else {
@@ -8899,7 +8584,7 @@ export class AdapterClass extends EventEmitter {
                 this._logger.debug(`${this.namespaceLog} Schedule restart: ${adapterConfig.common.restartSchedule}`);
                 this._restartScheduleJob = this._schedule.scheduleJob(adapterConfig.common.restartSchedule, () => {
                     this._logger.info(`${this.namespaceLog} Scheduled restart.`);
-                    this._stop({ isPause: false, isScheduled: true });
+                    this._stop({ isPause: false, isScheduled: true }).catch(e => this._logger.error(`${this.namespaceLog} Cannot stop adapter: ${e.message}`));
                 });
             }
         }
@@ -8930,13 +8615,13 @@ export class AdapterClass extends EventEmitter {
         if (this._config.isInstall &&
             (typeof this._options.install === 'function' || this.listeners('install').length)) {
             if (typeof this._options.install === 'function') {
-                this._options.install();
+                Promise.resolve(this._options.install()).catch(e => this._logger.error(`${this.namespaceLog} Error in install handler: ${e.message}`));
             }
             this.emit('install');
         }
         else {
             if (typeof this._options.ready === 'function') {
-                this._options.ready();
+                Promise.resolve(this._options.ready()).catch(e => this._logger.error(`${this.namespaceLog} Error in ready handler: ${e.message}`));
             }
             this.emit('ready');
         }
@@ -8990,7 +8675,7 @@ export class AdapterClass extends EventEmitter {
                     isScheduled: false,
                     exitCode: EXIT_CODES.UNCAUGHT_EXCEPTION,
                     updateAliveState: false,
-                });
+                }).catch(err => this._logger.error(`${this.namespaceLog} Cannot stop adapter: ${err.message}`));
             }
             catch (e) {
                 this._logger.error(`${this.namespaceLog} exception by stop: ${e ? e.message : e}`);
@@ -9077,7 +8762,7 @@ export class AdapterClass extends EventEmitter {
             });
         }
         return new Promise(resolve => {
-            this._extendObjects(objs, resolve);
+            return this._extendObjects(objs, resolve);
         });
     }
     /**
@@ -9127,7 +8812,7 @@ export class AdapterClass extends EventEmitter {
         return this.#states.setState(id, state);
     }
     async _extendObjects(tasks, callback) {
-        if (!tasks || !tasks.length) {
+        if (!tasks?.length) {
             return tools.maybeCallback(callback);
         }
         const task = tasks.shift();