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

package/build/cjs/lib/adapter/adapter.js

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -45,14 +46,18 @@ var import_node = __toESM(require("node.extend"), 1);
 var import_yargs = __toESM(require("yargs/yargs"), 1);
 var import_fs_extra = __toESM(require("fs-extra"), 1);
 var url = __toESM(require("node:url"), 1);
-var import_plugin_base = require("@iobroker/plugin-base");
 var import_js_controller_common = require("@iobroker/js-controller-common");
 var import_utils = require("../../lib/adapter/utils.js");
 var import_package = __toESM(require("@iobroker/js-controller-adapter/package.json"), 1);
 var import_log = require("../../lib/adapter/log.js");
 var import_validator = require("./validator.js");
 var import_constants = require("../../lib/adapter/constants.js");
+var import_plugin_base = require("@iobroker/plugin-base");
 var import_userInterfaceMessagingController = require("../../lib/adapter/userInterfaceMessagingController.js");
+var import_asyncAdapter = require("../../lib/adapter/asyncAdapter.js");
+var import_CertificateManager = require("../../lib/adapter/managers/CertificateManager.js");
+var import_AliasManager = require("../../lib/adapter/managers/AliasManager.js");
+var import_SubscriptionManager = require("../../lib/adapter/managers/SubscriptionManager.js");
 var import_constants2 = require("@iobroker/js-controller-common-db/constants");
 var import_tools = require("@iobroker/js-controller-common-db/tools");
 const controllerVersion = import_package.default.version;
@@ -60,6 +65,9 @@ const { FORBIDDEN_CHARS } = import_js_controller_common.tools;
 const thisDir = url.fileURLToPath(new URL(".", __import_meta_url || `file://${__filename}`));
 import_js_controller_common.tools.ensureDNSOrder();
 class AdapterClass extends import_node_events.EventEmitter {
+  static {
+    __name(this, "AdapterClass");
+  }
   /** Cache of all deprecations which have already been transmitted */
   reportedDeprecations = /* @__PURE__ */ new Set();
   /** Instance to access states DB */
@@ -76,14 +84,10 @@ class AdapterClass extends import_node_events.EventEmitter {
   startedInCompactMode;
   /** List of instances which want our logs */
   logList = /* @__PURE__ */ new Set();
-  aliases = /* @__PURE__ */ new Map();
-  aliasPatterns = /* @__PURE__ */ new Set();
   enums = {};
   eventLoopLags = [];
   overwriteLogLevel = false;
   adapterReady = false;
-  /** Callbacks from sendTo */
-  messageCallbacks = /* @__PURE__ */ 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.
@@ -95,7 +99,6 @@ class AdapterClass extends import_node_events.EventEmitter {
    */
   oObjects;
   _stopInProgress = false;
-  _callbackId = 1;
   _firstConnection = true;
   _timers = /* @__PURE__ */ new Set();
   _intervals = /* @__PURE__ */ new Set();
@@ -104,12 +107,14 @@ class AdapterClass extends import_node_events.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 */
@@ -123,8 +128,6 @@ class AdapterClass extends import_node_events.EventEmitter {
   // todo
   /** The cache of user groups */
   groups = {};
-  /** An array of instances, that support auto subscribe */
-  autoSubscribe = [];
   defaultHistory = null;
   pluginHandler;
   _reportInterval;
@@ -156,11 +159,9 @@ class AdapterClass extends import_node_events.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;
@@ -188,6 +189,32 @@ class AdapterClass extends import_node_events.EventEmitter {
   SUPPORTED_FEATURES = (0, import_utils.getSupportedFeatures)();
   /** Controller for messaging related functionality */
   uiMessagingController;
+  /** Shared runtime context handed to managers */
+  #context;
+  #async;
+  #certWatchers = /* @__PURE__ */ new Map();
+  #aliasInstance;
+  /** Lazily-constructed alias subscription manager. */
+  get #alias() {
+    return this.#aliasInstance ??= new import_AliasManager.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 import_SubscriptionManager.SubscriptionManager(this.#context, (id, isPattern) => this._utils.fixId(id, isPattern), this.#alias, {
+      getForeignStateObjects: /* @__PURE__ */ __name((pattern, options) => (
+        // @ts-expect-error adjust types
+        this.getForeignObjectsAsync(pattern, null, null, options)
+      ), "getForeignStateObjects")
+    });
+  }
+  /** 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();
     if (typeof options === "string") {
@@ -309,12 +336,41 @@ class AdapterClass extends import_node_events.EventEmitter {
       subscribeCallback: this._options.uiClientSubscribe,
       unsubscribeCallback: this._options.uiClientUnsubscribe
     });
+    const self = this;
+    this.#context = {
+      logger: this._logger,
+      uiMessagingController: this.uiMessagingController,
+      countOutput: /* @__PURE__ */ __name(() => {
+        self.outputCount++;
+      }, "countOutput"),
+      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 import_asyncAdapter.AsyncAdapter(this.#context);
     this.getPortAsync = import_js_controller_common.tools.promisifyNoError(this.getPort, this);
     this.checkPasswordAsync = import_js_controller_common.tools.promisifyNoError(this.checkPassword, this);
     this.setPasswordAsync = import_js_controller_common.tools.promisify(this.setPassword, this);
     this.checkGroupAsync = import_js_controller_common.tools.promisifyNoError(this.checkGroup, this);
     this.calculatePermissionsAsync = import_js_controller_common.tools.promisifyNoError(this.calculatePermissions, this);
-    this.getCertificatesAsync = import_js_controller_common.tools.promisify(this.getCertificates, this);
     this.setObjectAsync = import_js_controller_common.tools.promisify(this.setObject, this);
     this.getAdapterObjectsAsync = import_js_controller_common.tools.promisifyNoError(this.getAdapterObjects, this);
     this.extendObjectAsync = import_js_controller_common.tools.promisify(this.extendObject, this);
@@ -361,7 +417,6 @@ class AdapterClass extends import_node_events.EventEmitter {
     this.readFileAsync = import_js_controller_common.tools.promisify(this.readFile, this, ["file", "mimeType"]);
     this.writeFileAsync = import_js_controller_common.tools.promisify(this.writeFile, this);
     this.fileExistsAsync = import_js_controller_common.tools.promisify(this.fileExists, this);
-    this.sendToHostAsync = import_js_controller_common.tools.promisifyNoError(this.sendToHost, this);
     this.setStateAsync = import_js_controller_common.tools.promisify(this.setState, this);
     this.setStateChangedAsync = import_js_controller_common.tools.promisify(this.setStateChanged, this, ["id", "notChanged"]);
     this.setForeignStateAsync = import_js_controller_common.tools.promisify(this.setForeignState, this);
@@ -378,7 +433,7 @@ class AdapterClass extends import_node_events.EventEmitter {
     this.subscribeStatesAsync = import_js_controller_common.tools.promisify(this.subscribeStates, this);
     this.unsubscribeStatesAsync = import_js_controller_common.tools.promisify(this.unsubscribeStates, this);
     this.setExecutableCapabilities = import_js_controller_common.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
@@ -468,6 +523,12 @@ class AdapterClass extends import_node_events.EventEmitter {
     return import_js_controller_common.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) {
     import_validator.Validator.assertString(id, "id");
     import_validator.Validator.assertCallback(callback, "callback");
@@ -477,11 +538,19 @@ class AdapterClass extends import_node_events.EventEmitter {
   _getSession(options) {
     if (!this.#states) {
       this._logger.info(`${this.namespaceLog} getSession not processed because States database not connected`);
-      return import_js_controller_common.tools.maybeCallbackWithError(options.callback, import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
+      return import_js_controller_common.tools.maybeCallback(options.callback, null);
     }
-    this.#states.getSession(options.id, options.callback);
+    this.#states.getSession(options.id, (err, session) => import_js_controller_common.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) {
     import_validator.Validator.assertString(id, "id");
     import_validator.Validator.assertOptionalCallback(callback, "callback");
@@ -495,8 +564,14 @@ class AdapterClass extends import_node_events.EventEmitter {
       this._logger.info(`${this.namespaceLog} setSession not processed because States database not connected`);
       return import_js_controller_common.tools.maybeCallbackWithError(options.callback, import_js_controller_common.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) {
     import_validator.Validator.assertString(id, "id");
     import_validator.Validator.assertOptionalCallback(callback, "callback");
@@ -507,12 +582,11 @@ class AdapterClass extends import_node_events.EventEmitter {
       this._logger.info(`${this.namespaceLog} destroySession not processed because States database not connected`);
       return import_js_controller_common.tools.maybeCallbackWithError(options.callback, import_js_controller_common.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}`);
       return [];
@@ -532,7 +606,7 @@ class AdapterClass extends import_node_events.EventEmitter {
     }
     this.terminated = true;
     let shutdownStarted = false;
-    const shutdownLogic = () => {
+    const shutdownLogic = /* @__PURE__ */ __name(() => {
       if (shutdownStarted) {
         return;
       }
@@ -586,7 +660,7 @@ class AdapterClass extends import_node_events.EventEmitter {
           process.exit(_exitCode);
         }
       }, 500);
-    };
+    }, "shutdownLogic");
     if (this.pluginHandler) {
       this.pluginHandler.destroyAll().then(() => shutdownLogic()).catch(() => shutdownLogic());
     } else {
@@ -818,7 +892,7 @@ class AdapterClass extends import_node_events.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 import_js_controller_common.tools.maybeCallbackWithError(options.callback, "User does not exist");
       }
@@ -895,11 +969,11 @@ class AdapterClass extends import_node_events.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 import_js_controller_common.tools.maybeCallback(options.callback, false);
       }
-      this.getForeignObject(options.group, options, (err2, obj2) => {
+      return this.getForeignObject(options.group, options.options, (err2, obj2) => {
         if (err2 || !obj2) {
           return import_js_controller_common.tools.maybeCallback(options.callback, false);
         }
@@ -1004,7 +1078,7 @@ class AdapterClass extends import_node_events.EventEmitter {
    *        ```
    */
   calculatePermissions(user, commandsPermissions, options, callback) {
-    user = user || "";
+    user ||= "";
     if (typeof options === "function") {
       callback = options;
       options = null;
@@ -1017,7 +1091,12 @@ class AdapterClass extends import_node_events.EventEmitter {
       import_validator.Validator.assertObject(options, "options");
     }
     import_validator.Validator.assertOptionalCallback(callback, "callback");
-    return this._calculatePermissions({ user, commandsPermissions, options, callback });
+    return this._calculatePermissions({
+      user,
+      commandsPermissions,
+      options,
+      callback
+    });
   }
   async _calculatePermissions(options) {
     const { user } = options;
@@ -1102,15 +1181,15 @@ class AdapterClass extends import_node_events.EventEmitter {
             try {
               for (const type of Object.keys(gAcl)) {
                 if (type === "user") {
-                  acl.users = acl.users || {};
+                  acl.users ||= {};
                 } else {
-                  acl[type] = acl[type] || {};
+                  acl[type] ||= {};
                 }
                 for (const op of Object.keys(gAcl[type])) {
                   if (type === "user") {
-                    acl.users[op] = acl.users[op] || gAcl.user[op];
+                    acl.users[op] ||= gAcl.user[op];
                   } else {
-                    acl[type][op] = acl[type][op] || gAcl[type][op];
+                    acl[type][op] ||= gAcl[type][op];
                   }
                 }
               }
@@ -1142,7 +1221,7 @@ class AdapterClass extends import_node_events.EventEmitter {
       this._reportInterval && clearInterval(this._reportInterval);
       this._reportInterval = null;
       const id = `system.adapter.${this.namespace}`;
-      const finishUnload = async () => {
+      const finishUnload = /* @__PURE__ */ __name(async () => {
         if (this._timers.size) {
           this._timers.forEach((timer) => clearTimeout(timer));
           this._timers.clear();
@@ -1155,10 +1234,8 @@ class AdapterClass extends import_node_events.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 {
@@ -1171,14 +1248,17 @@ class AdapterClass extends import_node_events.EventEmitter {
           this._logger.info(`${this.namespaceLog} terminating`);
         }
         this.terminate(reason, exitCode);
-      };
+      }, "finishUnload");
       if (this.adapterReady) {
         if (typeof this._options.unload === "function") {
           if (this._options.unload.length >= 1) {
             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 {
-              finishUnload();
+              finishUnload().catch((e) => this._logger.error(`${this.namespaceLog} Error in finishUnload: ${e.message}`));
             }
           } else {
             const unloadPromise = this._options.unload();
@@ -1186,7 +1266,7 @@ class AdapterClass extends import_node_events.EventEmitter {
               try {
                 await unloadPromise;
               } finally {
-                finishUnload();
+                finishUnload().catch((e) => this._logger.error(`${this.namespaceLog} Error in finishUnload: ${e.message}`));
               }
             } else {
               this._logger.error(`${this.namespaceLog} Error in ${id}: The unload method must return a Promise if it does not accept a callback!`);
@@ -1200,38 +1280,109 @@ class AdapterClass extends import_node_events.EventEmitter {
         if (!this.#states) {
           updateAliveState = false;
         }
-        const terminate = () => {
+        const terminate = /* @__PURE__ */ __name(() => {
           if (!isPause) {
             this._logger.info(`${this.namespaceLog} terminating`);
           }
           this.terminate(exitCode);
-        };
+        }, "terminate");
         finishUnload().then(terminate, terminate);
       }, this.common?.stopTimeout || 500);
     }
   }
   /**
-   * 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 (cert.length < 1024 && import_fs_extra.default.existsSync(cert)) {
-          const certFile = cert;
-          cert = import_fs_extra.default.readFileSync(certFile, "utf8");
-          import_fs_extra.default.watch(certFile, (eventType, filename) => {
-            this._logger.warn(`${this.namespaceLog} New certificate "${filename}" detected. Restart adapter`);
-            setTimeout(() => this._stop({ isPause: false, isScheduled: true }), 2e3);
-          });
-        }
+        const watcher = import_fs_extra.default.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 }), 2e3);
+  }
+  /**
+   * 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;
+    }
+    this.#certObjectSubscribed = true;
+    try {
+      await this.#objects.subscribeAsync(import_CertificateManager.CERTIFICATES_OBJECT_ID);
+      if (!this.#certObjectSubscribed && this.#objects) {
+        await this.#objects.unsubscribeAsync(import_CertificateManager.CERTIFICATES_OBJECT_ID);
+      }
+    } catch (e) {
+      this.#certObjectSubscribed = false;
+      this._logger.error(`${this.namespaceLog} Cannot watch certificate object ${import_CertificateManager.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(import_CertificateManager.CERTIFICATES_OBJECT_ID);
+      } catch {
       }
     }
-    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
@@ -1265,59 +1416,16 @@ class AdapterClass extends import_node_events.EventEmitter {
       callback = chainedName;
       chainedName = void 0;
     }
-    const config = this.config;
-    publicName = publicName || config.certPublic;
-    privateName = privateName || config.certPrivate;
-    chainedName = chainedName || config.certChained;
-    if (publicName !== void 0) {
-      import_validator.Validator.assertString(publicName, "publicName");
-    }
-    if (privateName !== void 0) {
-      import_validator.Validator.assertString(privateName, "privateName");
-    }
-    if (chainedName !== void 0) {
-      import_validator.Validator.assertString(chainedName, "chainedName");
-    }
     import_validator.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 import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
-    }
-    try {
-      obj = await this.#objects.getObject("system.certificates");
-    } catch {
-    }
-    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 import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.tools.ERRORS.ERROR_NOT_FOUND);
-    }
-    let ca;
-    if (chainedName) {
-      const chained = this._readFileCertificate(obj.native.certificates[chainedName]).split("-----END CERTIFICATE-----\r\n");
-      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
-`);
-          }
-        }
-        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 import_js_controller_common.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.
@@ -1326,7 +1434,7 @@ class AdapterClass extends import_node_events.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`);
     }
@@ -1389,7 +1497,7 @@ class AdapterClass extends import_node_events.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.
    *
@@ -1404,14 +1512,12 @@ class AdapterClass extends import_node_events.EventEmitter {
   async _getEncryptedConfig(options) {
     const { attribute, callback } = options;
     const value = (0, import_utils.getObjectAttribute)(this.config, attribute);
+    if ((Array.isArray(value) || typeof value === "string") && this._decryptedNativeAttributes.includes(attribute)) {
+      return import_js_controller_common.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] = import_js_controller_common.tools.decrypt(secret, value[i]);
-        }
-      }
+      const result = value.map((item) => typeof item === "string" ? import_js_controller_common.tools.decrypt(secret, item) : item);
       return import_js_controller_common.tools.maybeCallbackWithError(callback, null, result);
     } else if (typeof value === "string") {
       const secret = await this.getSystemSecret();
@@ -1705,13 +1811,13 @@ class AdapterClass extends import_node_events.EventEmitter {
   }
   async _getAdapterObjects(options) {
     const ret = {};
-    const addRows = (rows) => {
+    const addRows = /* @__PURE__ */ __name((rows) => {
       if (rows) {
         for (const { id, value } of rows) {
           ret[id] = value;
         }
       }
-    };
+    }, "addRows");
     if (!this.#objects) {
       return import_js_controller_common.tools.maybeCallback(options.callback, ret);
     }
@@ -1767,7 +1873,7 @@ class AdapterClass extends import_node_events.EventEmitter {
    * }
    * ```
    *
-   * If following object will be passed as argument
+   * If the following object will be passed as an argument
    *
    * ```js
    * {
@@ -1868,28 +1974,28 @@ class AdapterClass extends import_node_events.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 : "") || import_constants.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 : "") || import_constants.SYSTEM_ADMIN_USER;
+      options.obj.ts ||= Date.now();
       options.obj = (0, import_node.default)(true, oldObj, options.obj);
       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 : "") || import_constants.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 : "") || import_constants.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 && !import_js_controller_common.tools.isObject(options.obj.common.custom)) {
         this._logger.error(`${this.namespaceLog} extendObject ${options.id} (type=${options.obj.type}) property common.custom is of type ${typeof options.obj.common.custom}, expected object.`);
         return import_js_controller_common.tools.maybeCallbackWithError(options.callback, "common.custom needs to be an object");
@@ -1904,12 +2010,12 @@ class AdapterClass extends import_node_events.EventEmitter {
       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 !== void 0) {
           defState = options.obj.common.def;
-        } else if (oldObj.common && oldObj.common.def !== void 0) {
+        } else if (oldObj.common?.def !== void 0) {
           defState = oldObj.common.def;
         }
       }
@@ -2068,28 +2174,28 @@ class AdapterClass extends import_node_events.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 || import_constants.SYSTEM_ADMIN_USER;
-      obj.ts = obj.ts || Date.now();
+      obj.from ||= `system.adapter.${this.namespace}`;
+      obj.user ||= options?.user || import_constants.SYSTEM_ADMIN_USER;
+      obj.ts ||= Date.now();
       obj = (0, import_node.default)(true, oldObj, obj);
-      return this.#objects.setObject(id, obj, options, callback);
+      return callback ? this.#objects.setObject(id, obj, options, callback) : this.#objects.setObject(id, obj, options);
     }
-    obj.from = obj.from || `system.adapter.${this.namespace}`;
-    obj.user = obj.user || options?.user || import_constants.SYSTEM_ADMIN_USER;
-    obj.ts = obj.ts || Date.now();
-    if (obj.type && obj.type === "state" || !obj.type && oldObj && oldObj.type === "state") {
+    obj.from ||= `system.adapter.${this.namespace}`;
+    obj.user ||= options?.user || import_constants.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 && !import_js_controller_common.tools.isObject(obj.common.custom)) {
         this._logger.error(`${this.namespaceLog} extendObject ${id} (type=${obj.type}) property common.custom is of type ${typeof obj.common.custom}, expected object.`);
         return import_js_controller_common.tools.maybeCallbackWithError(callback, "common.custom needs to be an object");
@@ -2104,12 +2210,12 @@ class AdapterClass extends import_node_events.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 !== void 0) {
+        if (obj.common && "def" in obj.common && obj.common?.def !== void 0) {
           defState = obj.common.def;
-        } else if (oldObj.common && oldObj.common.def !== void 0) {
+        } else if (oldObj.common?.def !== void 0) {
           defState = oldObj.common.def;
         }
         if (defState !== void 0) {
@@ -2242,7 +2348,7 @@ class AdapterClass extends import_node_events.EventEmitter {
     import_validator.Validator.assertString(design, "design");
     import_validator.Validator.assertString(search, "search");
     import_validator.Validator.assertOptionalCallback(callback, "callback");
-    params = params || {};
+    params ||= {};
     import_validator.Validator.assertObject(params, "params");
     if (options !== null && options !== void 0) {
       import_validator.Validator.assertObject(options, "options");
@@ -2503,9 +2609,7 @@ class AdapterClass extends import_node_events.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;
           }
         }
@@ -2712,7 +2816,7 @@ class AdapterClass extends import_node_events.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, id2, name) => {
@@ -2759,8 +2863,8 @@ class AdapterClass extends import_node_events.EventEmitter {
       return import_js_controller_common.tools.maybeCallbackWithError(options.callback, import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
     }
     try {
-      const obj = await this.#objects.getObjectAsync(options.id, options);
-      if (obj && "protectedNative" in obj && Array.isArray(obj.protectedNative) && obj._id && obj._id.startsWith("system.adapter.") && obj.native && !import_constants.NO_PROTECT_ADAPTERS.includes(this.name) && this.name !== obj._id.split(".")[2]) {
+      const obj = await this.#objects.getObjectAsync(options.id, options.options);
+      if (obj?.native && "protectedNative" in obj && Array.isArray(obj.protectedNative) && obj._id?.startsWith("system.adapter.") && !import_constants.NO_PROTECT_ADAPTERS.includes(this.name) && this.name !== obj._id.split(".")[2]) {
         for (const attr of obj.protectedNative) {
           (0, import_utils.deleteObjectAttribute)(obj.native, attr);
         }
@@ -2792,29 +2896,32 @@ class AdapterClass extends import_node_events.EventEmitter {
     id = this._utils.fixId(id);
     this.delForeignObject(id, options, callback);
   }
-  _deleteObjects(tasks, options, cb) {
-    if (!tasks || !tasks.length) {
+  async _deleteObjects(tasks, options, cb) {
+    if (!tasks?.length) {
       return import_js_controller_common.tools.maybeCallback(cb);
     }
-    const task = tasks.shift();
-    this.#objects.delObject(task.id, options, async (err) => {
-      if (err) {
-        return import_js_controller_common.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 import_js_controller_common.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 import_js_controller_common.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 import_js_controller_common.tools.maybeCallbackWithError(cb, err);
+    }
+    return import_js_controller_common.tools.maybeCallback(cb);
   }
   /**
    * Delete any object.
@@ -2862,16 +2969,17 @@ class AdapterClass extends import_node_events.EventEmitter {
         const tasks = obj && (!obj.common || !obj.common.dontDelete) ? [{ id, state: obj.type === "state" }] : [];
         const selector = { startkey: `${id}.`, endkey: `${id}.\u9999` };
         this.#objects.getObjectList(selector, options, (err2, 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);
         });
       });
     } else {
       this.#objects.getObject(id, options, async (err, obj) => {
         if (err) {
           return import_js_controller_common.tools.maybeCallbackWithError(callback, err);
-        } else if (obj) {
+        }
+        if (obj) {
           if (obj.common?.dontDelete) {
             return import_js_controller_common.tools.maybeCallbackWithError(callback, new Error("not deletable"));
           }
@@ -2918,16 +3026,8 @@ class AdapterClass extends import_node_events.EventEmitter {
     if (options !== null && options !== void 0) {
       import_validator.Validator.assertObject(options, "options");
     }
-    if (!this.#objects) {
-      this._logger.info(`${this.namespaceLog} subscribeObjects not processed because Objects database not connected`);
-      return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.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.
@@ -2951,16 +3051,8 @@ class AdapterClass extends import_node_events.EventEmitter {
     if (options !== null && options !== void 0) {
       import_validator.Validator.assertObject(options, "options");
     }
-    if (!this.#objects) {
-      this._logger.info(`${this.namespaceLog} unsubscribeObjects not processed because Objects database not connected`);
-      return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.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.
@@ -2984,11 +3076,8 @@ class AdapterClass extends import_node_events.EventEmitter {
     if (options !== null && options !== void 0) {
       import_validator.Validator.assertObject(options, "options");
     }
-    if (!this.#objects) {
-      this._logger.info(`${this.namespaceLog} subscribeForeignObjects not processed because Objects database not connected`);
-      return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.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.
@@ -3015,11 +3104,8 @@ class AdapterClass extends import_node_events.EventEmitter {
     if (options !== null && options !== void 0) {
       import_validator.Validator.assertObject(options, "options");
     }
-    if (!this.#objects) {
-      this._logger.info(`${this.namespaceLog} unsubscribeForeignObjects not processed because Objects database not connected`);
-      return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.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.
@@ -3029,16 +3115,12 @@ class AdapterClass extends import_node_events.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(import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
-    }
     import_validator.Validator.assertString(id, "id");
     import_validator.Validator.assertPattern(pattern, "pattern");
     if (options !== null && options !== void 0) {
       import_validator.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.
@@ -3051,16 +3133,12 @@ class AdapterClass extends import_node_events.EventEmitter {
     if (!pattern) {
       pattern = "*";
     }
-    if (!this.#objects) {
-      this._logger.info(`${this.namespaceLog} unsubscribeForeignFiles not processed because Objects database not connected`);
-      throw new Error(import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
-    }
     import_validator.Validator.assertString(id, "id");
     import_validator.Validator.assertPattern(pattern, "pattern");
     if (options !== null && options !== void 0) {
       import_validator.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.
@@ -3208,11 +3286,11 @@ class AdapterClass extends import_node_events.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) {
@@ -3249,25 +3327,28 @@ class AdapterClass extends import_node_events.EventEmitter {
   _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,
       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) {
@@ -3300,28 +3381,29 @@ class AdapterClass extends import_node_events.EventEmitter {
     import_validator.Validator.assertString(channelName, "channelName");
     import_validator.Validator.assertString(parentDevice, "parentDevice");
     import_validator.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, "_");
     channelName = this._DCS2ID(parentDevice, channelName);
-    _native = _native || {};
+    _native ||= {};
     const obj = {
+      _id: channelName,
       type: "channel",
       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) {
@@ -3347,12 +3429,13 @@ class AdapterClass extends import_node_events.EventEmitter {
         read: true,
         write: false,
         name: "",
-        role: roleOrCommon
+        role: roleOrCommon,
+        type: "mixed"
       };
     } else if (import_js_controller_common.tools.isObject(roleOrCommon)) {
       common = roleOrCommon;
     }
-    _native = _native || {};
+    _native ||= {};
     import_validator.Validator.assertObject(common, "common");
     import_validator.Validator.assertString(stateName, "stateName");
     import_validator.Validator.assertString(parentDevice, "parentDevice");
@@ -3367,9 +3450,9 @@ class AdapterClass extends import_node_events.EventEmitter {
   _createState(_options) {
     const { _native, common, callback, options } = _options;
     let { parentChannel, parentDevice, stateName } = _options;
-    common.name = common.name || stateName;
-    common.read = common.read === void 0 ? true : common.read;
-    common.write = common.write === void 0 ? 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;
@@ -3438,35 +3521,36 @@ class AdapterClass extends import_node_events.EventEmitter {
         common.def = max;
       }
     }
-    this.setObjectNotExists(id, {
+    const stateResult = this.setObjectNotExists(id, {
       type: "state",
       common,
       native: _native
     }, options, (err) => {
       if (err) {
         return import_js_controller_common.tools.maybeCallbackWithError(callback, err);
-      } else if (common.def !== void 0) {
+      }
+      if (common.def !== void 0) {
         this.getState(id, null, (err2, state) => {
           if (!state) {
             if (common.defAck !== void 0) {
-              this.setState(id, common.def, common.defAck, options, callback);
-            } else {
-              this.setState(id, common.def, options, callback);
+              return this.setState(id, common.def, common.defAck, options, callback);
             }
-          } else {
-            return import_js_controller_common.tools.maybeCallback(callback);
+            return this.setState(id, common.def, options, callback);
           }
+          return import_js_controller_common.tools.maybeCallback(callback);
         });
       } else {
         this.getState(id, null, (err2, state) => {
           if (!state) {
-            this.setState(id, null, true, options, callback);
-          } else {
-            return import_js_controller_common.tools.maybeCallback(callback);
+            return this.setState(id, null, true, options, callback);
           }
+          return import_js_controller_common.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.
@@ -3518,6 +3602,16 @@ class AdapterClass extends import_node_events.EventEmitter {
     }
     return import_js_controller_common.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;
@@ -3564,10 +3658,9 @@ class AdapterClass extends import_node_events.EventEmitter {
             obj.from = `system.adapter.${this.namespace}`;
             obj.user = options?.user || import_constants.SYSTEM_ADMIN_USER;
             obj.ts = Date.now();
-            this.#objects.setObject(obj._id, obj, options, callback);
-          } else {
-            return import_js_controller_common.tools.maybeCallback(callback);
+            return callback ? this.#objects.setObject(obj._id, obj, options, callback) : this.#objects.setObject(obj._id, obj, options);
           }
+          return import_js_controller_common.tools.maybeCallback(callback);
         }
       });
     } else {
@@ -3584,25 +3677,35 @@ class AdapterClass extends import_node_events.EventEmitter {
             obj.from = `system.adapter.${this.namespace}`;
             obj.user = options?.user || import_constants.SYSTEM_ADMIN_USER;
             obj.ts = Date.now();
-            this.#objects.setObject(obj._id, obj, options, callback);
-          } else {
-            return import_js_controller_common.tools.maybeCallback(callback);
+            return callback ? this.#objects.setObject(obj._id, obj, options, callback) : this.#objects.setObject(obj._id, obj, options);
           }
-        } else {
-          this.#objects.setObject(`enum.${enumName}.${addTo}`, {
-            common: {
-              name: addTo,
-              members: [objId]
-            },
-            from: `system.adapter.${this.namespace}`,
-            ts: Date.now(),
-            type: "enum",
-            native: {}
-          }, options, callback);
+          return import_js_controller_common.tools.maybeCallback(callback);
         }
+        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) : 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;
@@ -3755,11 +3858,11 @@ class AdapterClass extends import_node_events.EventEmitter {
     return import_js_controller_common.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) {
@@ -3841,6 +3944,12 @@ class AdapterClass extends import_node_events.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;
@@ -3879,6 +3988,13 @@ class AdapterClass extends import_node_events.EventEmitter {
       return import_js_controller_common.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;
@@ -3926,6 +4042,14 @@ class AdapterClass extends import_node_events.EventEmitter {
       return import_js_controller_common.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;
@@ -4002,6 +4126,17 @@ class AdapterClass extends import_node_events.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;
@@ -4061,10 +4196,9 @@ class AdapterClass extends import_node_events.EventEmitter {
           obj.from = `system.adapter.${this.namespace}`;
           obj.user = options?.user || import_constants.SYSTEM_ADMIN_USER;
           obj.ts = Date.now();
-          this.#objects.setObject(obj._id, obj, options, callback);
-        } else {
-          return import_js_controller_common.tools.maybeCallback(callback);
+          return callback ? this.#objects.setObject(obj._id, obj, options, callback) : this.#objects.setObject(obj._id, obj, options);
         }
+        return import_js_controller_common.tools.maybeCallback(callback);
       });
     } else {
       if (enumName.startsWith("enum.")) {
@@ -4077,28 +4211,39 @@ class AdapterClass extends import_node_events.EventEmitter {
             obj.from = `system.adapter.${this.namespace}`;
             obj.user = options?.user || import_constants.SYSTEM_ADMIN_USER;
             obj.ts = Date.now();
-            this.#objects.setObject(obj._id, obj, callback);
-          } else {
-            return import_js_controller_common.tools.maybeCallback(callback);
-          }
-        } else {
-          if (err) {
-            return import_js_controller_common.tools.maybeCallbackWithError(callback, err);
+            return callback ? this.#objects.setObject(obj._id, obj, callback) : this.#objects.setObject(obj._id, obj);
           }
-          this.#objects.setObject(`enum.${enumName}.${addTo}`, {
-            common: {
-              name: addTo,
-              members: [objId]
-            },
-            from: `system.adapter.${this.namespace}`,
-            ts: Date.now(),
-            type: "enum",
-            native: {}
-          }, options, callback);
+          return import_js_controller_common.tools.maybeCallback(callback);
+        }
+        if (err) {
+          return import_js_controller_common.tools.maybeCallbackWithError(callback, err);
         }
+        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) : 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;
@@ -4312,6 +4457,14 @@ class AdapterClass extends import_node_events.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;
@@ -4332,6 +4485,15 @@ class AdapterClass extends import_node_events.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;
@@ -4351,8 +4513,16 @@ class AdapterClass extends import_node_events.EventEmitter {
       this._logger.info(`${this.namespaceLog} rename not processed because Objects database not connected`);
       return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.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;
@@ -4489,6 +4659,13 @@ class AdapterClass extends import_node_events.EventEmitter {
       return import_js_controller_common.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;
@@ -4506,6 +4683,13 @@ class AdapterClass extends import_node_events.EventEmitter {
       value.toFixed(decimals).replace(format[0], format[1]).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;
@@ -4552,7 +4736,7 @@ class AdapterClass extends import_node_events.EventEmitter {
     const validFormatChars = "YJ\u0413M\u041CDT\u0414hS\u0447m\u043Cs\u0441";
     let s = "";
     let result = "";
-    const put = (s2) => {
+    const put = /* @__PURE__ */ __name((s2) => {
       let v = "";
       switch (s2) {
         case "YYYY":
@@ -4630,7 +4814,7 @@ class AdapterClass extends import_node_events.EventEmitter {
           v = v.toString();
       }
       return result += v;
-    };
+    }, "put");
     for (let i = 0; i < format.length; i++) {
       if (validFormatChars.includes(format[i])) {
         s += format[i];
@@ -4678,13 +4862,42 @@ class AdapterClass extends import_node_events.EventEmitter {
     if (options !== void 0) {
       import_validator.Validator.assertObject(options, "options");
     }
-    return this._sendTo({
-      instanceName,
-      command,
-      message,
-      options,
-      callback
-    });
+    if (import_js_controller_common.tools.isObject(callback)) {
+      this.#fireAndForget(this.#async.sendTo(instanceName, command, message, this.#withSendFlags(options, { 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 !== void 0 && !import_js_controller_common.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
@@ -4696,105 +4909,15 @@ class AdapterClass extends import_node_events.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);
-      };
-      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) {
-      return import_js_controller_common.tools.maybeCallbackWithError(callback, "No instanceName provided or not a string");
-    }
-    if (!instanceName.startsWith("system.adapter.")) {
-      instanceName = `system.adapter.${instanceName}`;
-    }
-    if (!this.#states) {
-      this._logger.info(`${this.namespaceLog} sendTo not processed because States database not connected`);
-      return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.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 (!instanceName.match(/\.[0-9]+$/)) {
-      if (!this.#objects) {
-        this._logger.info(`${this.namespaceLog} sendTo not processed because Objects database not connected`);
-        return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
-      }
-      try {
-        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) {
-              return import_js_controller_common.tools.maybeCallbackWithError(callback, e);
-            }
-          }
-        }
-      } catch {
-      }
-    } else {
-      if (callback) {
-        if (typeof callback === "function") {
-          if (!(0, import_utils.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 >= 4294967295) {
-            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 });
-          const now = Date.now();
-          for (const [_id, cb] of this.messageCallbacks) {
-            if (now - cb.time > 36e5) {
-              this.messageCallbacks.delete(_id);
-            }
-          }
-        } else {
-          obj.callback = callback;
-          obj.callback.ack = true;
-        }
-      }
-      try {
-        await this.#states.pushMessage(instanceName, obj);
-      } catch (e) {
-        return import_js_controller_common.tools.maybeCallbackWithError(callback, e);
-      }
+    if (typeof message === "function") {
+      options = void 0;
+      message = command;
+      command = "send";
+    } 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.
@@ -4814,6 +4937,10 @@ class AdapterClass extends import_node_events.EventEmitter {
    *        ```
    */
   sendToHost(hostName, command, message, callback) {
+    if (typeof message === "function" && typeof callback === "undefined") {
+      callback = message;
+      message = void 0;
+    }
     if (typeof message === "undefined") {
       message = command;
       command = "send";
@@ -4825,77 +4952,32 @@ class AdapterClass extends import_node_events.EventEmitter {
     if (!import_js_controller_common.tools.isObject(callback)) {
       import_validator.Validator.assertOptionalCallback(callback, "callback");
     }
-    return this._sendToHost({
-      hostName,
-      command,
-      message,
-      callback
-    });
-  }
-  async _sendToHost(_options) {
-    const { command, message, callback } = _options;
-    let { hostName } = _options;
-    const obj = { command, message, from: `system.adapter.${this.namespace}` };
-    if (!this.#states) {
-      this._logger.info(`${this.namespaceLog} sendToHost not processed because States database not connected`);
-      return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
+    if (import_js_controller_common.tools.isObject(callback)) {
+      this.#fireAndForget(this.#async.sendToHost(hostName, command, message, {
+        callback
+      }), "Error in sendToHost");
+      return;
     }
-    if (hostName && !hostName.startsWith("system.host.")) {
-      hostName = `system.host.${hostName}`;
+    const cb = callback;
+    if (typeof cb === "function" && hostName !== null) {
+      this.sendToHostAsync(hostName, command, message).then((reply) => cb(reply), (err) => cb(err));
+      return;
     }
-    if (!hostName) {
-      if (!this.#objects) {
-        this._logger.info(`${this.namespaceLog} sendToHost not processed because Objects database not connected`);
-        return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
-      }
-      this.#objects.getObjectList({
-        startkey: "system.host.",
-        endkey: `system.host.\u9999`
-      }, null, async (err, res) => {
-        if (!this.#states) {
-          return;
-        }
-        if (!err && res?.rows.length) {
-          for (const row of res.rows) {
-            const parts = row.id.split(".");
-            if (parts.length === 3) {
-              try {
-                await this.#states.pushMessage(row.id, obj);
-              } catch (e) {
-                return import_js_controller_common.tools.maybeCallbackWithError(callback, e);
-              }
-            }
-          }
-        }
-      });
-    } else {
-      if (callback) {
-        if (typeof callback === "function") {
-          if (!(0, import_utils.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 >= 4294967295) {
-            this._callbackId = 1;
-          }
-          this.messageCallbacks.set(obj.callback.id, { cb: callback, time: Date.now() });
-        } else {
-          obj.callback = callback;
-          obj.callback.ack = true;
-        }
-      }
-      try {
-        await this.#states.pushMessage(hostName, obj);
-      } catch (e) {
-        return import_js_controller_common.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";
     }
+    return this.#async.sendToHost(hostName, command, message, { expectReply: hostName !== null });
   }
   /**
    * Send a message to an active UI Client
@@ -4903,22 +4985,7 @@ class AdapterClass extends import_node_events.EventEmitter {
    * @param options clientId and data options
    */
   sendToUI(options) {
-    if (!this.#states) {
-      throw new Error(import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
-    }
-    const { clientId, data } = options;
-    if (clientId === void 0) {
-      return this.uiMessagingController.sendToAllClients({
-        data,
-        states: this.#states
-      });
-    }
-    import_validator.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
@@ -4929,30 +4996,80 @@ class AdapterClass extends import_node_events.EventEmitter {
    * @param options - Additional options for the notification, currently `contextData` is supported
    */
   async registerNotification(scope, category, message, options) {
-    if (!this.#states) {
-      this._logger.info(`${this.namespaceLog} registerNotification not processed because States database not connected`);
-      throw new Error(import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
-    }
-    import_validator.Validator.assertString(scope, "scope");
-    if (category !== null) {
-      import_validator.Validator.assertString(category, "category");
-    }
-    import_validator.Validator.assertString(message, "message");
-    if (options !== void 0) {
-      import_validator.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 === void 0 ? this.#async.getHostUsedResources() : this.#async.getHostUsedResources(type);
   }
   /**
    * Writes value into states DB.
@@ -5155,8 +5272,7 @@ class AdapterClass extends import_node_events.EventEmitter {
     }
     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);
     const user = this.users[options.user];
@@ -5166,71 +5282,71 @@ class AdapterClass extends import_node_events.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;
           user.acl.file.delete = group.common.acl.file.delete;
           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;
           user.acl.object.delete = group.common.acl.object.delete;
           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;
           user.acl.users.delete = group.common.acl.users.delete;
           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;
           user.acl.state.delete = group.common.acl.state.delete;
           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;
         }
       }
     }
@@ -5238,10 +5354,17 @@ class AdapterClass extends import_node_events.EventEmitter {
     return options;
   }
   _checkState(obj, options, command) {
+    if (options.groups?.includes(import_constants.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 (options.user === obj.acl.owner) {
           if (command === "setState" || command === "delState") {
             if (command === "delState" && !options.acl.state.delete) {
@@ -5262,7 +5385,7 @@ class AdapterClass extends import_node_events.EventEmitter {
           } else {
             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}`);
@@ -5630,7 +5753,7 @@ class AdapterClass extends import_node_events.EventEmitter {
           this.outputCount++;
           this.#states.setState(aliasId, import_js_controller_common.tools.formatAliasValue({
             sourceCommon: obj?.common,
-            targetCommon: targetObj && targetObj.common,
+            targetCommon: targetObj?.common,
             state,
             logger: this._logger,
             logNamespace: this.namespaceLog,
@@ -5805,7 +5928,7 @@ class AdapterClass extends import_node_events.EventEmitter {
    *            }
    *        ```
    *
-   *        See possible attributes of the state in @setState explanation
+   *        See possible attributes of the state in `setState` explanation
    */
   getState(id, options, callback) {
     if (!import_js_controller_common.tools.isObject(id)) {
@@ -5828,7 +5951,7 @@ class AdapterClass extends import_node_events.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") {
@@ -5918,7 +6041,7 @@ class AdapterClass extends import_node_events.EventEmitter {
       if (this.oStates && this.oStates[id]) {
         return import_js_controller_common.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
@@ -5996,7 +6119,7 @@ class AdapterClass extends import_node_events.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") {
@@ -6019,10 +6142,10 @@ class AdapterClass extends import_node_events.EventEmitter {
     } catch (e) {
       return import_js_controller_common.tools.maybeCallbackWithError(callback, e);
     }
-    options = options || {};
-    options.end = options.end || Date.now() + 5e6;
+    options ||= {};
+    options.end ||= Date.now() + 5e6;
     if (!options.count && !options.start) {
-      options.start = options.start || Date.now() - 6048e5;
+      options.start ||= Date.now() - 6048e5;
     }
     if (!options.instance) {
       if (!this.defaultHistory) {
@@ -6065,7 +6188,7 @@ class AdapterClass extends import_node_events.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.
@@ -6106,7 +6229,7 @@ class AdapterClass extends import_node_events.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.
    *
@@ -6147,7 +6270,11 @@ class AdapterClass extends import_node_events.EventEmitter {
         return import_js_controller_common.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
@@ -6181,7 +6308,7 @@ class AdapterClass extends import_node_events.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) {
@@ -6295,7 +6422,7 @@ class AdapterClass extends import_node_events.EventEmitter {
           return import_js_controller_common.tools.maybeCallbackWithError(callback, e);
         }
       } else {
-        const res = await this._processStates(pattern, options?._objects);
+        const res = await this._processStates(pattern, options._objects);
         return import_js_controller_common.tools.maybeCallbackWithError(callback, null, res);
       }
     } else {
@@ -6354,76 +6481,6 @@ class AdapterClass extends import_node_events.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") {
-      return;
-    }
-    if (!aliasObj.common?.alias?.id) {
-      this._logger.warn(`${this.namespaceLog} Alias ${aliasObj._id} has no target 5`);
-      throw new Error(`Alias ${aliasObj._id} has no target`);
-    }
-    const sourceId = import_js_controller_common.tools.isObject(aliasObj.common.alias.id) ? aliasObj.common.alias.id.read : aliasObj.common.alias.id;
-    try {
-      this._utils.validateId(sourceId, true, null);
-    } catch (e) {
-      throw new Error(`Error validating alias id of ${aliasObj._id}: ${e.message}`);
-    }
-    const targetEntry = {
-      alias: (0, import_deep_clone.default)(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: [] };
-      this.aliases.set(sourceId, aliasDetails);
-    } else {
-      aliasDetails = this.aliases.get(sourceId);
-    }
-    if (!aliasDetails.source) {
-      await this.#states.subscribe(sourceId);
-      const sourceObj = await this.#objects.getObject(sourceId, { user: import_constants.SYSTEM_ADMIN_USER });
-      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
-        };
-      }
-    }
-    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);
-    const pos = typeof aliasObjOrIdx === "number" ? aliasObjOrIdx : alias.targets.indexOf(aliasObjOrIdx);
-    if (pos !== -1) {
-      alias.targets.splice(pos, 1);
-      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
    *
@@ -6450,136 +6507,8 @@ class AdapterClass extends import_node_events.EventEmitter {
       import_validator.Validator.assertObject(options, "options");
     }
     import_validator.Validator.assertPattern(pattern, "pattern");
-    return this._subscribeForeignStates({ pattern, options, callback });
-  }
-  async _subscribeForeignStates(_options) {
-    const { pattern, options, callback } = _options;
-    await this._autoSubscribeOn();
-    if (!this.#states) {
-      this._logger.info(`${this.namespaceLog} subscribeForeignStates not processed because States database not connected`);
-      return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
-    }
-    if (!this.#objects) {
-      this._logger.info(`${this.namespaceLog} subscribeForeignStates not processed because Objects database not connected`);
-      return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
-    }
-    for (const autoSubEntry of this.autoSubscribe) {
-      if (typeof pattern === "string" && (pattern === "*" || pattern.startsWith(`${autoSubEntry}.`))) {
-        let state;
-        try {
-          state = await this.#states.getState(`system.adapter.${autoSubEntry}.subscribes`);
-        } catch {
-        }
-        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"`);
-        }
-        if (!import_js_controller_common.tools.isObject(subs)) {
-          subs = {};
-        }
-        if (!import_js_controller_common.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)) {
-      const aliasesIds = pattern.map((id) => id.startsWith(import_constants.ALIAS_STARTS_WITH) ? id : null).filter((id) => id);
-      const nonAliasesIds = pattern.map((id) => !id.startsWith(import_constants.ALIAS_STARTS_WITH) ? id : null).filter((id) => id);
-      for (const aliasPattern of pattern) {
-        if ((aliasPattern.startsWith(import_constants.ALIAS_STARTS_WITH) || aliasPattern.includes("*")) && !this.aliasPatterns.has(aliasPattern)) {
-          this.aliasPatterns.add(aliasPattern);
-        }
-      }
-      const promises = [];
-      if (aliasesIds.length) {
-        if (!this._aliasObjectsSubscribed) {
-          this._aliasObjectsSubscribed = true;
-          this.#objects.subscribe(`${import_constants.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 import_js_controller_common.tools.maybeCallback(callback);
-    } else if (pattern.includes("*")) {
-      if (pattern === "*" || pattern.startsWith(import_constants.ALIAS_STARTS_WITH)) {
-        if (!this._aliasObjectsSubscribed) {
-          this._aliasObjectsSubscribed = true;
-          this.#objects.subscribe(`${import_constants.ALIAS_STARTS_WITH}*`);
-        }
-        try {
-          const objs = await this.getForeignObjectsAsync(pattern, null, null, options);
-          const promises = [];
-          if (!this.aliasPatterns.has(pattern)) {
-            this.aliasPatterns.add(pattern);
-          }
-          for (const id of Object.keys(objs)) {
-            if (id.startsWith(import_constants.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) {
-            this._logger.info(`${this.namespaceLog} subscribeForeignStates not processed because States database not connected`);
-            return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
-          }
-          if (promises.length && pattern !== "*") {
-            return import_js_controller_common.tools.maybeCallback(callback);
-          }
-          this.#states.subscribeUser(pattern, callback);
-        } catch (e) {
-          this._logger.warn(`${this.namespaceLog} Cannot subscribe to ${pattern}: ${e.message}`);
-          return import_js_controller_common.tools.maybeCallbackWithError(callback, e);
-        }
-      } else {
-        this.#states.subscribeUser(pattern, callback);
-      }
-    } else if (pattern.startsWith(import_constants.ALIAS_STARTS_WITH)) {
-      if (!this._aliasObjectsSubscribed) {
-        this._aliasObjectsSubscribed = true;
-        this.#objects.subscribe(`${import_constants.ALIAS_STARTS_WITH}*`);
-      }
-      try {
-        const aliasObj = await this.#objects.getObject(pattern, options);
-        if (aliasObj) {
-          await this._addAliasSubscribe(aliasObj, pattern);
-          return import_js_controller_common.tools.maybeCallback(callback);
-        }
-        return import_js_controller_common.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
@@ -6612,85 +6541,8 @@ class AdapterClass extends import_node_events.EventEmitter {
     if (options !== null && options !== void 0) {
       import_validator.Validator.assertObject(options, "options");
     }
-    return this._unsubscribeForeignStates({ pattern, options, callback });
-  }
-  async _unsubscribeForeignStates(_options) {
-    const { pattern, callback } = _options;
-    if (!this.#states) {
-      this._logger.info(`${this.namespaceLog} unsubscrubeForeignStates not processed because States database not connected`);
-      return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.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}.`) {
-          let state;
-          try {
-            state = await this.#states.getState(`system.adapter.${autoSub}.subscribes`);
-          } catch {
-          }
-          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 (!import_js_controller_common.tools.isObject(subs) || !import_js_controller_common.tools.isObject(subs[pattern]) || subs[pattern][this.namespace] === void 0) {
-            continue;
-          }
-          if (typeof subs[pattern][this.namespace] === "number") {
-            subs[pattern][this.namespace]--;
-            if (subs[pattern][this.namespace] <= 0) {
-              delete subs[pattern][this.namespace];
-            }
-          } else {
-            delete subs[pattern][this.namespace];
-          }
-          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)) {
-      for (const _pattern of pattern) {
-        promises.push(this.unsubscribeForeignStatesAsync(_pattern));
-      }
-    } else if (pattern.includes("*") || pattern.startsWith(import_constants.ALIAS_STARTS_WITH)) {
-      if (pattern === "*" || pattern.startsWith(import_constants.ALIAS_STARTS_WITH)) {
-        aliasPattern = pattern;
-        if (pattern === "*") {
-          promises.push(this.#states.unsubscribeUser(pattern));
-        }
-      } else {
-        promises.push(this.#states.unsubscribeUser(pattern));
-      }
-    } else {
-      promises.push(this.#states.unsubscribeUser(pattern));
-    }
-    if (aliasPattern) {
-      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 (!this.aliases.size && this._aliasObjectsSubscribed) {
-      this._aliasObjectsSubscribed = false;
-      this.#objects.unsubscribe(`${import_constants.ALIAS_STARTS_WITH}*`);
-    }
-    return import_js_controller_common.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
@@ -6714,11 +6566,8 @@ class AdapterClass extends import_node_events.EventEmitter {
     if (options !== null && options !== void 0) {
       import_validator.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.
@@ -6744,11 +6593,8 @@ class AdapterClass extends import_node_events.EventEmitter {
     if (options !== null && options !== void 0) {
       import_validator.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
@@ -6776,27 +6622,6 @@ class AdapterClass extends import_node_events.EventEmitter {
     import_validator.Validator.assertString(name, "name");
     return this.pluginHandler.getPluginConfig(name);
   }
-  async _autoSubscribeOn() {
-    if (!this.autoSubscribe && this.#objects) {
-      try {
-        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);
-            if (!this.autoSubscribe.includes(_id)) {
-              this.autoSubscribe.push(_id);
-            }
-          }
-        }
-        await this.#objects.subscribeAsync("system.adapter.*");
-      } catch {
-      }
-    }
-  }
   /**
    * This method returns the list of license that can be used by this adapter
    *
@@ -6902,7 +6727,7 @@ class AdapterClass extends import_node_events.EventEmitter {
       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`, {
@@ -6910,24 +6735,24 @@ class AdapterClass extends import_node_events.EventEmitter {
         ack: true,
         expire: reportStatusExpirySec,
         from: id
-      });
+      }).catch((e) => this._logger.error(`${this.namespaceLog} Cannot set connected state: ${e.message}`));
       this.outputCount++;
     }
     if (!this.startedInCompactMode) {
       (0, import_pidusage.default)(process.pid, (err, stats) => {
-        if (!err && this && this.#states && this.#states.setState && stats) {
+        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
-          });
+          }).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 / 1e3,
             expire: reportStatusExpirySec
-          });
+          }).catch((e) => this._logger.error(`${this.namespaceLog} Cannot set cputime state: ${e.message}`));
           this.outputCount += 2;
         }
       });
@@ -6938,19 +6763,19 @@ class AdapterClass extends import_node_events.EventEmitter {
           ack: true,
           from: id,
           expire: reportStatusExpirySec
-        });
+        }).catch((e) => this._logger.error(`${this.namespaceLog} Cannot set memRss state: ${e.message}`));
         this.#states.setState(`${id}.memHeapTotal`, {
           val: parseFloat((mem.heapTotal / 1048576).toFixed(2)),
           ack: true,
           from: id,
           expire: reportStatusExpirySec
-        });
+        }).catch((e) => this._logger.error(`${this.namespaceLog} Cannot set memHeapTotal state: ${e.message}`));
         this.#states.setState(`${id}.memHeapUsed`, {
           val: parseFloat((mem.heapUsed / 1048576).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}`);
       }
@@ -6962,7 +6787,7 @@ class AdapterClass extends import_node_events.EventEmitter {
           ack: true,
           from: id,
           expire: reportStatusExpirySec
-        });
+        }).catch((e) => this._logger.error(`${this.namespaceLog} Cannot set eventLoopLag state: ${e.message}`));
         this.eventLoopLags = [];
         this.outputCount++;
       }
@@ -6973,19 +6798,19 @@ class AdapterClass extends import_node_events.EventEmitter {
       ack: true,
       from: id,
       expire: reportStatusExpirySec
-    });
+    }).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
-    });
+    }).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;
   }
@@ -7053,7 +6878,7 @@ class AdapterClass extends import_node_events.EventEmitter {
         }
       } else if (this.#states?.pushLog) {
         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}`));
         }
       }
     });
@@ -7077,7 +6902,7 @@ class AdapterClass extends import_node_events.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}`));
             }
           }
         }
@@ -7139,7 +6964,7 @@ class AdapterClass extends import_node_events.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) => {
         if (isActive) {
@@ -7168,7 +6993,7 @@ class AdapterClass extends import_node_events.EventEmitter {
     this.#states = new this.States({
       namespace: this.namespaceLog,
       connection: this._config.states,
-      connected: async () => {
+      connected: /* @__PURE__ */ __name(async () => {
         if (!this.#states) {
           return;
         }
@@ -7179,11 +7004,11 @@ class AdapterClass extends import_node_events.EventEmitter {
           this._initializeTimeout = null;
         }
         if (!this._config.isInstall) {
-          this.#states.subscribe(`system.adapter.${this.namespace}.sigKill`);
-          this.#states.subscribe(`system.adapter.${this.namespace}.logLevel`);
+          this.#states.subscribe(`system.adapter.${this.namespace}.sigKill`).catch((e) => this._logger.error(`${this.namespaceLog} Cannot subscribe to sigKill: ${e.message}`));
+          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) {
-          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}`));
           let state;
           try {
             state = await this.#states.getStateAsync(`system.adapter.${this.namespace}.subscribes`);
@@ -7202,9 +7027,9 @@ class AdapterClass extends import_node_events.EventEmitter {
           return import_js_controller_common.tools.maybeCallback(cb);
         }
         return import_js_controller_common.tools.maybeCallback(cb);
-      },
+      }, "connected"),
       logger: this._logger,
-      change: async (id, stateOrMessage) => {
+      change: /* @__PURE__ */ __name(async (id, stateOrMessage) => {
         this.inputCount++;
         const state = stateOrMessage;
         if (!id || typeof id !== "string") {
@@ -7225,7 +7050,7 @@ class AdapterClass extends import_node_events.EventEmitter {
                 isScheduled: false,
                 exitCode: import_js_controller_common.EXIT_CODES.ADAPTER_REQUESTED_TERMINATION,
                 updateAliveState: false
-              });
+              }).catch((e) => this._logger.error(`${this.namespaceLog} Cannot stop adapter: ${e.message}`));
             }
           }
         }
@@ -7236,12 +7061,9 @@ class AdapterClass extends import_node_events.EventEmitter {
             if (state.val && state.val !== currentLevel && (0, import_tools.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;
-                }
-                if (!this._logger.transports[transport]._defaultConfigLoglevel) {
-                  this._logger.transports[transport].level = newLogLevel;
+              for (const transport of this._logger.transports) {
+                if (!transport._defaultConfigLoglevel) {
+                  transport.level = newLogLevel;
                 }
               }
               this._logger.info(`${this.namespaceLog} Loglevel changed from "${currentLevel}" to "${state.val}"`);
@@ -7254,7 +7076,7 @@ class AdapterClass extends import_node_events.EventEmitter {
               val: currentLevel,
               ack: true,
               from: `system.adapter.${this.namespace}`
-            });
+            }).catch((e) => this._logger.error(`${this.namespaceLog} Cannot set logLevel state: ${e.message}`));
           }
         }
         if (id === `system.adapter.${this.namespace}.checkLogging`) {
@@ -7286,25 +7108,7 @@ class AdapterClass extends import_node_events.EventEmitter {
         } else if (id === `messagebox.system.adapter.${this.namespace}` && state) {
           const obj = state;
           if (obj) {
-            let callbackObj;
-            if (obj.callback?.id) {
-              callbackObj = this.messageCallbacks.get(obj.callback.id);
-            }
-            if (obj.callback?.ack && obj.callback.id && callbackObj) {
-              if (typeof callbackObj.cb === "function") {
-                callbackObj.cb(obj.message);
-                if (callbackObj.timer) {
-                  clearTimeout(callbackObj.timer);
-                }
-                this.messageCallbacks.delete(obj.callback.id);
-              }
-              const now = Date.now();
-              for (const [_id, callback] of this.messageCallbacks) {
-                if (now - callback.time > 36e5) {
-                  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);
@@ -7314,7 +7118,7 @@ class AdapterClass extends import_node_events.EventEmitter {
                 return this.uiMessagingController.removeClientSubscribeByMessage(obj);
               }
               if (this._options.message) {
-                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);
             }
@@ -7345,36 +7149,17 @@ class AdapterClass extends import_node_events.EventEmitter {
               }
             }
           }
-        } else if (!this._stopInProgress && this.adapterReady && this.aliases.has(id)) {
-          const alias = this.aliases.get(id);
-          const uniqueTargets = /* @__PURE__ */ new Set();
-          for (const target of alias.targets) {
-            const targetId = target.id;
-            if (uniqueTargets.has(targetId)) {
-              continue;
-            }
-            uniqueTargets.add(targetId);
-            const source = alias.source;
-            const aState = state ? import_js_controller_common.tools.formatAliasValue({
-              sourceCommon: source,
-              targetCommon: target,
-              state: (0, import_deep_clone.default)(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 {
-                setImmediate(() => this.emit("stateChange", targetId, aState));
-              }
+        } 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}`));
+            } else {
+              setImmediate(() => this.emit("stateChange", targetId, aState));
             }
           }
         }
-      },
-      changeUser: (id, state) => {
+      }, "change"),
+      changeUser: /* @__PURE__ */ __name((id, state) => {
         this.inputCount++;
         if (!id || typeof id !== "string") {
           this._logger.warn(`${this.namespaceLog} Invalid id on state change: ${JSON.stringify(id)}`);
@@ -7396,17 +7181,17 @@ class AdapterClass extends import_node_events.EventEmitter {
             }
           }
         }
-      },
-      disconnected: () => {
+      }, "changeUser"),
+      disconnected: /* @__PURE__ */ __name(() => {
         this.connected = false;
         !this.terminated && setTimeout(() => {
           if (this.connected) {
             return;
           }
           this._logger.warn(`${this.namespaceLog} Cannot connect/reconnect to states DB. Stopping adapter.`);
-          this._stop({ exitCode: import_js_controller_common.EXIT_CODES.NO_ERROR, updateAliveState: false });
+          this._stop({ exitCode: import_js_controller_common.EXIT_CODES.NO_ERROR, updateAliveState: false }).catch((e) => this._logger.error(`${this.namespaceLog} Cannot stop adapter: ${e.message}`));
         }, 5e3);
-      }
+      }, "disconnected")
     });
   }
   _initObjects(cb) {
@@ -7427,7 +7212,7 @@ class AdapterClass extends import_node_events.EventEmitter {
       namespace: this.namespaceLog,
       connection: this._config.objects,
       logger: this._logger,
-      connected: async () => {
+      connected: /* @__PURE__ */ __name(async () => {
         this.connected = true;
         if (this._initializeTimeout) {
           clearTimeout(this._initializeTimeout);
@@ -7457,25 +7242,31 @@ class AdapterClass extends import_node_events.EventEmitter {
         } else {
           return import_js_controller_common.tools.maybeCallback(cb);
         }
-      },
-      disconnected: () => {
+      }, "connected"),
+      disconnected: /* @__PURE__ */ __name(() => {
         this.connected = false;
         !this.terminated && setTimeout(() => {
           if (this.connected) {
             return;
           }
           this._logger.warn(`${this.namespaceLog} Cannot connect/reconnect to objects DB. Stopping adapter.`);
-          this._stop({ exitCode: import_js_controller_common.EXIT_CODES.NO_ERROR, updateAliveState: false });
+          this._stop({ exitCode: import_js_controller_common.EXIT_CODES.NO_ERROR, updateAliveState: false }).catch((e) => this._logger.error(`${this.namespaceLog} Cannot stop adapter: ${e.message}`));
         }, 4e3);
-      },
-      change: async (id, obj) => {
+      }, "disconnected"),
+      change: /* @__PURE__ */ __name(async (id, obj) => {
         if (!id) {
           this._logger.error(`${this.namespaceLog} change ID is empty: ${JSON.stringify(obj)}`);
           return;
         }
         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;
+        }
+        if (id === import_CertificateManager.CERTIFICATES_OBJECT_ID) {
+          if (this.#async.hasRelevantCertificateChange(obj)) {
+            this.#scheduleCertificateRestart("Changed certificate detected");
+          }
           return;
         }
         if (id === "system.config" && obj?.common && (this._options.useFormatDate || this.defaultHistory !== void 0)) {
@@ -7487,57 +7278,15 @@ class AdapterClass extends import_node_events.EventEmitter {
           this.defaultHistory = obj.common.defaultHistory;
         }
         if (id.startsWith(import_constants.ALIAS_STARTS_WITH)) {
-          let isNewAlias = true;
-          for (const [sourceId, alias] of this.aliases) {
-            const targetAlias = alias.targets.find((entry) => entry.id === id);
-            if (targetAlias) {
-              isNewAlias = false;
-              if (obj?.common?.alias?.id) {
-                const newSourceId = typeof obj.common.alias.id.read === "string" ? obj.common.alias.id.read : obj.common.alias.id;
-                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 {
-                  targetAlias.min = obj.common.min;
-                  targetAlias.max = obj.common.max;
-                  targetAlias.type = obj.common.type;
-                  targetAlias.alias = (0, import_deep_clone.default)(obj.common.alias);
-                }
-              } else {
-                await this._removeAliasSubscribe(sourceId, targetAlias);
-              }
-            }
-          }
-          if (isNewAlias && obj) {
-            for (const aliasPattern of this.aliasPatterns) {
-              const testPattern = aliasPattern.slice(-1) === "*" ? new RegExp(import_js_controller_common.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);
         }
         if (id.startsWith("system.adapter.")) {
           if (obj?.common?.subscribable) {
             const _id = id.substring(15);
             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);
             }
           }
         }
@@ -7553,8 +7302,8 @@ class AdapterClass extends import_node_events.EventEmitter {
             this.enums[id] = obj;
           }
         }
-      },
-      changeUser: (id, obj) => {
+      }, "change"),
+      changeUser: /* @__PURE__ */ __name((id, obj) => {
         if (!id) {
           this._logger.error(`${this.namespaceLog} change ID is empty: ${JSON.stringify(obj)}`);
           return;
@@ -7578,8 +7327,8 @@ class AdapterClass extends import_node_events.EventEmitter {
             setImmediate(() => this.emit("objectChange", id, obj));
           }
         }
-      },
-      changeFileUser: (id, fileName, size) => {
+      }, "changeUser"),
+      changeFileUser: /* @__PURE__ */ __name((id, fileName, size) => {
         if (!id) {
           this._logger.error(`${this.namespaceLog} change file name is empty`);
           return;
@@ -7588,7 +7337,7 @@ class AdapterClass extends import_node_events.EventEmitter {
           typeof this._options.fileChange === "function" && setImmediate(() => this._options.fileChange(id, fileName, size));
           setImmediate(() => this.emit("fileChange", id, fileName, size));
         }
-      }
+      }, "changeFileUser")
     });
   }
   /**
@@ -7645,7 +7394,7 @@ class AdapterClass extends import_node_events.EventEmitter {
     if (!this.#states || !this.#objects || this.terminated) {
       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 === void 0) {
       if (!adapterConfig || !("common" in adapterConfig) || !adapterConfig.common.enabled) {
         if (adapterConfig && "common" in adapterConfig && adapterConfig.common.enabled !== void 0) {
@@ -7721,13 +7470,12 @@ class AdapterClass extends import_node_events.EventEmitter {
       } else {
         this.stop = (params) => this._stop({ ...params, isPause: false });
       }
-      this.#states.subscribe(`${import_constants2.SYSTEM_ADAPTER_PREFIX}*.logging`);
+      this.#states.subscribe(`${import_constants2.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
       !(0, import_utils.isMessageboxSupported)(adapterConfig.common)) {
         this._logger.error(`${this.namespaceLog} : message handler implemented, but messagebox not enabled. Define common.messagebox in io-package.json for adapter or delete message handler.`);
       } else if ((0, import_utils.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 {
       this.name = adapterConfig.name || this.name;
@@ -7739,19 +7487,22 @@ class AdapterClass extends import_node_events.EventEmitter {
       this.host = this.common?.host || import_js_controller_common.tools.getHostName();
     }
     this.adapterConfig = adapterConfig;
-    this._utils = new import_validator.Validator(this.#objects, this.#states, this.namespaceLog, this._logger, this.namespace, this._namespaceRegExp);
+    this._utils = new import_validator.Validator(this.#objects, this.namespaceLog, this._logger, this.namespace, this._namespaceRegExp);
     this.log = new import_log.Log(this.namespaceLog, this._config.log.level, this._logger);
     await this._createInstancesObjects(adapterConfig);
     if (this._options.objects) {
       this.oObjects = await this.getAdapterObjectsAsync();
       await this.subscribeObjectsAsync("*");
     }
-    await this.getSystemSecret();
-    const promises = [];
+    const secret = await this.getSystemSecret();
     if (Array.isArray(adapterConfig.encryptedNative)) {
+      this._decryptedNativeAttributes = new Array();
       for (const attr of adapterConfig.encryptedNative) {
-        if (typeof this.config[attr] === "string") {
-          promises.push(this.getEncryptedConfig(attr).then((decryptedValue) => (0, import_utils.setObjectAttribute)(this.config, attr, decryptedValue)).catch((e) => this._logger.error(`${this.namespaceLog} Can not decrypt attribute ${attr}: ${e.message}`)));
+        try {
+          (0, import_utils.decryptArray)({ obj: this.config, secret, keys: [attr] });
+          this._decryptedNativeAttributes.push(attr);
+        } catch (e) {
+          this._logger.error(`${this.namespaceLog} Can not decrypt attribute ${attr}: ${e.message}`);
         }
       }
     } else {
@@ -7760,7 +7511,6 @@ class AdapterClass extends import_node_events.EventEmitter {
         this.SUPPORTED_FEATURES.splice(idx, 1);
       }
     }
-    await Promise.all(promises);
     if (!this.#states) {
       return;
     }
@@ -7769,7 +7519,7 @@ class AdapterClass extends import_node_events.EventEmitter {
       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();
     } catch (e) {
@@ -7792,15 +7542,18 @@ class AdapterClass extends import_node_events.EventEmitter {
           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 = /* @__PURE__ */ __name((e) => {
+            this._logger.error(`${this.namespaceLog} Cannot reset compact metric: ${e.message}`);
+          }, "onErr");
+          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 {
           import_js_controller_common.tools.measureEventLoopLag(1e3, (lag) => {
@@ -7821,7 +7574,7 @@ class AdapterClass extends import_node_events.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}`));
         });
       }
     }
@@ -7849,12 +7602,12 @@ class AdapterClass extends import_node_events.EventEmitter {
   _callReadyHandler() {
     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");
     }
@@ -7900,7 +7653,7 @@ class AdapterClass extends import_node_events.EventEmitter {
           isScheduled: false,
           exitCode: import_js_controller_common.EXIT_CODES.UNCAUGHT_EXCEPTION,
           updateAliveState: false
-        });
+        }).catch((err2) => this._logger.error(`${this.namespaceLog} Cannot stop adapter: ${err2.message}`));
       } catch (e) {
         this._logger.error(`${this.namespaceLog} exception by stop: ${e ? e.message : e}`);
       }
@@ -7973,7 +7726,7 @@ class AdapterClass extends import_node_events.EventEmitter {
       });
     }
     return new Promise((resolve) => {
-      this._extendObjects(objs, resolve);
+      return this._extendObjects(objs, resolve);
     });
   }
   /**
@@ -8023,7 +7776,7 @@ class AdapterClass extends import_node_events.EventEmitter {
     return this.#states.setState(id, state);
   }
   async _extendObjects(tasks, callback) {
-    if (!tasks || !tasks.length) {
+    if (!tasks?.length) {
       return import_js_controller_common.tools.maybeCallback(callback);
     }
     const task = tasks.shift();
@@ -8130,7 +7883,7 @@ class AdapterClass extends import_node_events.EventEmitter {
    * Initializes the adapter
    */
   async _init() {
-    const _initDBs = () => {
+    const _initDBs = /* @__PURE__ */ __name(() => {
       this._initObjects(() => {
         if (this.inited) {
           this._logger.warn(`${this.namespaceLog} Reconnection to DB.`);
@@ -8139,7 +7892,7 @@ class AdapterClass extends import_node_events.EventEmitter {
         this.inited = true;
         this._initStates(() => this._prepareInitAdapter());
       });
-    };
+    }, "_initDBs");
     if (import_fs_extra.default.existsSync(`${this.adapterDir}/package.json`)) {
       this.pack = import_fs_extra.default.readJSONSync(`${this.adapterDir}/package.json`);
     } else {