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

package/build/cjs/lib/adapter/managers/AliasManager.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/lib/adapter/managers/AliasManager.ts"],
+  "sourcesContent": ["import { tools } from '@iobroker/js-controller-common';\nimport deepClone from 'deep-clone';\nimport type { AliasDetails, AliasTargetEntry } from '../../_Types.js';\nimport type { ValidateIdOptions } from '@/lib/adapter/validator.js';\nimport type { AdapterContext } from '@/lib/adapter/context.js';\nimport { AdapterContextBase } from '@/lib/adapter/managers/AdapterContextBase.js';\nimport { ALIAS_STARTS_WITH, SYSTEM_ADMIN_USER } from '@/lib/adapter/constants.js';\n\n/** Validates a (possibly foreign) id; throws on invalid. Bound to the adapter's Validator. */\nexport type ValidateId = (id: string, isForeignId: boolean, options?: ValidateIdOptions | null) => void;\n\n/**\n * Owns the alias subscription cache and its bookkeeping: which real (source) states feed which\n * `alias.*` targets, the alias subscription patterns, and the single `alias.*` object subscription.\n * The source-state change fan-out ({@link resolveSourceChange}) is synchronous by contract so the\n * state-change handler cannot interleave a cache mutation mid-fan-out.\n */\nexport class AliasManager extends AdapterContextBase {\n    readonly #aliases = new Map<string, AliasDetails>();\n    readonly #aliasPatterns = new Set<string>();\n    #aliasObjectsSubscribed = false;\n    readonly #validateId: ValidateId;\n\n    /**\n     * @param ctx Shared adapter context providing live runtime state\n     * @param validateId Bound id validator from the adapter's Validator instance\n     */\n    constructor(ctx: AdapterContext, validateId: ValidateId) {\n        super(ctx);\n        this.#validateId = validateId;\n    }\n\n    /**\n     * Whether the given source (real) state id currently feeds any alias.\n     *\n     * @param id the real source state id\n     */\n    hasSource(id: string): boolean {\n        return this.#aliases.has(id);\n    }\n\n    /** Number of tracked source states. */\n    get size(): number {\n        return this.#aliases.size;\n    }\n\n    /**\n     * Whether the given subscription pattern is tracked.\n     *\n     * @param pattern the subscription pattern\n     */\n    hasPattern(pattern: string): boolean {\n        return this.#aliasPatterns.has(pattern);\n    }\n\n    /**\n     * Track a subscription pattern.\n     *\n     * @param pattern the subscription pattern\n     */\n    addPattern(pattern: string): void {\n        this.#aliasPatterns.add(pattern);\n    }\n\n    /**\n     * Stop tracking a subscription pattern.\n     *\n     * @param pattern the subscription pattern\n     */\n    deletePattern(pattern: string): void {\n        this.#aliasPatterns.delete(pattern);\n    }\n\n    /**\n     * Whether `id` falls into any tracked alias pattern (wildcards via pattern2RegEx).\n     *\n     * @param id the id to test against the tracked patterns\n     */\n    matchesAnyPattern(id: string): boolean {\n        for (const aliasPattern of this.#aliasPatterns) {\n            const testPattern =\n                aliasPattern.slice(-1) === '*' ? new RegExp(tools.pattern2RegEx(aliasPattern)) : aliasPattern;\n            if (\n                (typeof testPattern === 'string' && aliasPattern === id) ||\n                (testPattern instanceof RegExp && testPattern.test(id))\n            ) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n    /**\n     * Reacts to a change of an `alias.*` object: re-points, updates, or removes the target across the\n     * tracked sources, and picks up a newly-appeared alias that falls into a tracked pattern.\n     * Live-iterates the cache while awaiting add/remove \u2014 the loop lives here, with the map, to\n     * preserve the original mutation-during-iteration semantics exactly.\n     *\n     * @param id the changed alias object id\n     * @param obj the new object (null/undefined if deleted)\n     */\n    async handleAliasObjectChange(id: string, obj: ioBroker.Object | null | undefined): Promise<void> {\n        let isNewAlias = true;\n        for (const [sourceId, alias] of this.#aliases) {\n            const targetAlias = alias.targets.find(entry => entry.id === id);\n            if (targetAlias) {\n                isNewAlias = false;\n                if (obj?.common?.alias?.id) {\n                    const newSourceId =\n                        typeof obj.common.alias.id.read === 'string' ? obj.common.alias.id.read : obj.common.alias.id;\n                    if (newSourceId !== sourceId) {\n                        await this.removeAliasSubscribe(sourceId, targetAlias);\n                        try {\n                            await this.addAliasSubscribe(obj, targetAlias.pattern);\n                        } catch (e: any) {\n                            this.logger.error(`${this.namespaceLog} Could not add alias subscription: ${e.message}`);\n                        }\n                    } else {\n                        targetAlias.min = obj.common.min;\n                        targetAlias.max = obj.common.max;\n                        targetAlias.type = obj.common.type;\n                        targetAlias.alias = deepClone(obj.common.alias);\n                    }\n                } else {\n                    await this.removeAliasSubscribe(sourceId, targetAlias);\n                }\n            }\n        }\n        if (isNewAlias && obj && this.matchesAnyPattern(id)) {\n            try {\n                await this.addAliasSubscribe(obj, id);\n            } catch (e: any) {\n                this.logger.warn(`${this.namespaceLog} Could not add alias subscription: ${e.message}`);\n            }\n        }\n    }\n\n    /**\n     * Removes every target subscribed under the given pattern, live-iterating the cache so a removal\n     * mutating the map mid-loop keeps the original semantics. Awaits each removal.\n     *\n     * @param pattern the subscription pattern being unsubscribed\n     */\n    async removeTargetsForPattern(pattern: string): Promise<void> {\n        const promises = new Array<Promise<void>>();\n        for (const [sourceId, alias] of this.#aliases) {\n            for (let i = alias.targets.length - 1; i >= 0; i--) {\n                if (alias.targets[i].pattern === pattern) {\n                    promises.push(this.removeAliasSubscribe(sourceId, i));\n                }\n            }\n        }\n        await Promise.all(promises);\n    }\n\n    /**\n     * Synchronously computes the fan-out of a source (real) state change to its alias targets.\n     * Returns one `{ targetId, state }` per unique target. MUST NOT await \u2014 the caller relies on the\n     * cache not mutating between read and emit.\n     *\n     * @param sourceId the changed real state id\n     * @param state the new state value (or null on deletion)\n     */\n    resolveSourceChange(\n        sourceId: string,\n        state: ioBroker.State | null | undefined,\n    ): Array<{ targetId: string; state: ioBroker.State | null }> {\n        const out = new Array<{ targetId: string; state: ioBroker.State | null }>();\n        const alias = this.#aliases.get(sourceId);\n        if (!alias) {\n            return out;\n        }\n        const uniqueTargets = new Set<string>();\n        for (const target of alias.targets) {\n            const targetId = target.id;\n            if (uniqueTargets.has(targetId)) {\n                continue;\n            }\n            uniqueTargets.add(targetId);\n            const aState = state\n                ? tools.formatAliasValue({\n                      sourceCommon: alias.source,\n                      targetCommon: target,\n                      state: deepClone(state),\n                      logger: this.logger,\n                      logNamespace: this.namespaceLog,\n                      sourceId,\n                      targetId,\n                  })\n                : null;\n            if (aState || !state) {\n                out.push({ targetId, state: aState });\n            }\n        }\n        return out;\n    }\n\n    /** Subscribe the `alias.*` object range once (idempotent). */\n    ensureAliasObjectSubscription(): void {\n        if (!this.#aliasObjectsSubscribed) {\n            this.#aliasObjectsSubscribed = true;\n            this.objects.subscribe(`${ALIAS_STARTS_WITH}*`);\n        }\n    }\n\n    /** Drop the `alias.*` object subscription when no aliases remain. */\n    maybeDropAliasObjectSubscription(): void {\n        if (!this.#aliases.size && this.#aliasObjectsSubscribed) {\n            this.#aliasObjectsSubscribed = false;\n            this.objects.unsubscribe(`${ALIAS_STARTS_WITH}*`);\n        }\n    }\n\n    /**\n     * Register an alias target for its source state, subscribing the source state (and reading its\n     * metadata once). Preserves the create-before-await ordering and the post-await existence\n     * re-check that guard a concurrent removal.\n     *\n     * @param aliasObj the `alias.*` object being subscribed\n     * @param pattern the subscription pattern that pulled it in\n     */\n    async addAliasSubscribe(aliasObj: ioBroker.AnyObject, pattern: string): Promise<void> {\n        if (aliasObj.type !== 'state') {\n            return;\n        }\n        if (!aliasObj.common?.alias?.id) {\n            this.logger.warn(`${this.namespaceLog} Alias ${aliasObj._id} has no target 5`);\n            throw new Error(`Alias ${aliasObj._id} has no target`);\n        }\n        const sourceId = tools.isObject(aliasObj.common.alias.id)\n            ? aliasObj.common.alias.id.read\n            : aliasObj.common.alias.id;\n        try {\n            this.#validateId(sourceId, true, null);\n        } catch (e: any) {\n            throw new Error(`Error validating alias id of ${aliasObj._id}: ${e.message}`);\n        }\n        const targetEntry: AliasTargetEntry = {\n            alias: deepClone(aliasObj.common.alias),\n            id: aliasObj._id,\n            pattern,\n            type: aliasObj.common.type,\n            max: aliasObj.common.max,\n            min: aliasObj.common.min,\n            unit: aliasObj.common.unit,\n        };\n        let aliasDetails: AliasDetails;\n        if (!this.#aliases.has(sourceId)) {\n            aliasDetails = { targets: [] };\n            this.#aliases.set(sourceId, aliasDetails);\n        } else {\n            aliasDetails = this.#aliases.get(sourceId)!;\n        }\n        if (!aliasDetails.source) {\n            await this.states.subscribe(sourceId);\n            const sourceObj = await this.objects.getObject(sourceId, { user: SYSTEM_ADMIN_USER });\n            if (sourceObj?.common && this.#aliases.has(sourceObj._id)) {\n                aliasDetails.source = {\n                    min: sourceObj.common.min,\n                    max: sourceObj.common.max,\n                    type: sourceObj.common.type,\n                    unit: sourceObj.common.unit,\n                };\n            }\n        }\n        aliasDetails.targets.push(targetEntry);\n    }\n\n    /**\n     * Remove one alias target from its source; when the source has no targets left, delete the entry\n     * and unsubscribe the source state.\n     *\n     * @param sourceId the real source state id\n     * @param aliasObjOrIdx the target entry or its index in the targets array\n     */\n    async removeAliasSubscribe(sourceId: string, aliasObjOrIdx: number | AliasTargetEntry): Promise<void> {\n        if (!this.#aliases.has(sourceId)) {\n            return;\n        }\n        const alias = this.#aliases.get(sourceId)!;\n        const pos = typeof aliasObjOrIdx === 'number' ? aliasObjOrIdx : alias.targets.indexOf(aliasObjOrIdx);\n        if (pos !== -1) {\n            alias.targets.splice(pos, 1);\n            if (!alias.targets.length) {\n                this.#aliases.delete(sourceId);\n                await this.states.unsubscribe(sourceId);\n            }\n        }\n    }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAAA,kCAAsB;AACtB,wBAAsB;AAItB,gCAAmC;AACnC,uBAAqD;AAW/C,MAAO,qBAAqB,6CAAkB;EAjBpD,OAiBoD;;;EACvC,WAAW,oBAAI,IAAG;EAClB,iBAAiB,oBAAI,IAAG;EACjC,0BAA0B;EACjB;;;;;EAMT,YAAY,KAAqB,YAAsB;AACnD,UAAM,GAAG;AACT,SAAK,cAAc;EACvB;;;;;;EAOA,UAAU,IAAU;AAChB,WAAO,KAAK,SAAS,IAAI,EAAE;EAC/B;;EAGA,IAAI,OAAI;AACJ,WAAO,KAAK,SAAS;EACzB;;;;;;EAOA,WAAW,SAAe;AACtB,WAAO,KAAK,eAAe,IAAI,OAAO;EAC1C;;;;;;EAOA,WAAW,SAAe;AACtB,SAAK,eAAe,IAAI,OAAO;EACnC;;;;;;EAOA,cAAc,SAAe;AACzB,SAAK,eAAe,OAAO,OAAO;EACtC;;;;;;EAOA,kBAAkB,IAAU;AACxB,eAAW,gBAAgB,KAAK,gBAAgB;AAC5C,YAAM,cACF,aAAa,MAAM,EAAE,MAAM,MAAM,IAAI,OAAO,kCAAM,cAAc,YAAY,CAAC,IAAI;AACrF,UACK,OAAO,gBAAgB,YAAY,iBAAiB,MACpD,uBAAuB,UAAU,YAAY,KAAK,EAAE,GACvD;AACE,eAAO;MACX;IACJ;AACA,WAAO;EACX;;;;;;;;;;EAWA,MAAM,wBAAwB,IAAY,KAAuC;AAC7E,QAAI,aAAa;AACjB,eAAW,CAAC,UAAU,KAAK,KAAK,KAAK,UAAU;AAC3C,YAAM,cAAc,MAAM,QAAQ,KAAK,WAAS,MAAM,OAAO,EAAE;AAC/D,UAAI,aAAa;AACb,qBAAa;AACb,YAAI,KAAK,QAAQ,OAAO,IAAI;AACxB,gBAAM,cACF,OAAO,IAAI,OAAO,MAAM,GAAG,SAAS,WAAW,IAAI,OAAO,MAAM,GAAG,OAAO,IAAI,OAAO,MAAM;AAC/F,cAAI,gBAAgB,UAAU;AAC1B,kBAAM,KAAK,qBAAqB,UAAU,WAAW;AACrD,gBAAI;AACA,oBAAM,KAAK,kBAAkB,KAAK,YAAY,OAAO;YACzD,SAAS,GAAQ;AACb,mBAAK,OAAO,MAAM,GAAG,KAAK,YAAY,sCAAsC,EAAE,OAAO,EAAE;YAC3F;UACJ,OAAO;AACH,wBAAY,MAAM,IAAI,OAAO;AAC7B,wBAAY,MAAM,IAAI,OAAO;AAC7B,wBAAY,OAAO,IAAI,OAAO;AAC9B,wBAAY,YAAQ,kBAAAA,SAAU,IAAI,OAAO,KAAK;UAClD;QACJ,OAAO;AACH,gBAAM,KAAK,qBAAqB,UAAU,WAAW;QACzD;MACJ;IACJ;AACA,QAAI,cAAc,OAAO,KAAK,kBAAkB,EAAE,GAAG;AACjD,UAAI;AACA,cAAM,KAAK,kBAAkB,KAAK,EAAE;MACxC,SAAS,GAAQ;AACb,aAAK,OAAO,KAAK,GAAG,KAAK,YAAY,sCAAsC,EAAE,OAAO,EAAE;MAC1F;IACJ;EACJ;;;;;;;EAQA,MAAM,wBAAwB,SAAe;AACzC,UAAM,WAAW,IAAI,MAAK;AAC1B,eAAW,CAAC,UAAU,KAAK,KAAK,KAAK,UAAU;AAC3C,eAAS,IAAI,MAAM,QAAQ,SAAS,GAAG,KAAK,GAAG,KAAK;AAChD,YAAI,MAAM,QAAQ,CAAC,EAAE,YAAY,SAAS;AACtC,mBAAS,KAAK,KAAK,qBAAqB,UAAU,CAAC,CAAC;QACxD;MACJ;IACJ;AACA,UAAM,QAAQ,IAAI,QAAQ;EAC9B;;;;;;;;;EAUA,oBACI,UACA,OAAwC;AAExC,UAAM,MAAM,IAAI,MAAK;AACrB,UAAM,QAAQ,KAAK,SAAS,IAAI,QAAQ;AACxC,QAAI,CAAC,OAAO;AACR,aAAO;IACX;AACA,UAAM,gBAAgB,oBAAI,IAAG;AAC7B,eAAW,UAAU,MAAM,SAAS;AAChC,YAAM,WAAW,OAAO;AACxB,UAAI,cAAc,IAAI,QAAQ,GAAG;AAC7B;MACJ;AACA,oBAAc,IAAI,QAAQ;AAC1B,YAAM,SAAS,QACT,kCAAM,iBAAiB;QACnB,cAAc,MAAM;QACpB,cAAc;QACd,WAAO,kBAAAA,SAAU,KAAK;QACtB,QAAQ,KAAK;QACb,cAAc,KAAK;QACnB;QACA;OACH,IACD;AACN,UAAI,UAAU,CAAC,OAAO;AAClB,YAAI,KAAK,EAAE,UAAU,OAAO,OAAM,CAAE;MACxC;IACJ;AACA,WAAO;EACX;;EAGA,gCAA6B;AACzB,QAAI,CAAC,KAAK,yBAAyB;AAC/B,WAAK,0BAA0B;AAC/B,WAAK,QAAQ,UAAU,GAAG,kCAAiB,GAAG;IAClD;EACJ;;EAGA,mCAAgC;AAC5B,QAAI,CAAC,KAAK,SAAS,QAAQ,KAAK,yBAAyB;AACrD,WAAK,0BAA0B;AAC/B,WAAK,QAAQ,YAAY,GAAG,kCAAiB,GAAG;IACpD;EACJ;;;;;;;;;EAUA,MAAM,kBAAkB,UAA8B,SAAe;AACjE,QAAI,SAAS,SAAS,SAAS;AAC3B;IACJ;AACA,QAAI,CAAC,SAAS,QAAQ,OAAO,IAAI;AAC7B,WAAK,OAAO,KAAK,GAAG,KAAK,YAAY,UAAU,SAAS,GAAG,kBAAkB;AAC7E,YAAM,IAAI,MAAM,SAAS,SAAS,GAAG,gBAAgB;IACzD;AACA,UAAM,WAAW,kCAAM,SAAS,SAAS,OAAO,MAAM,EAAE,IAClD,SAAS,OAAO,MAAM,GAAG,OACzB,SAAS,OAAO,MAAM;AAC5B,QAAI;AACA,WAAK,YAAY,UAAU,MAAM,IAAI;IACzC,SAAS,GAAQ;AACb,YAAM,IAAI,MAAM,gCAAgC,SAAS,GAAG,KAAK,EAAE,OAAO,EAAE;IAChF;AACA,UAAM,cAAgC;MAClC,WAAO,kBAAAA,SAAU,SAAS,OAAO,KAAK;MACtC,IAAI,SAAS;MACb;MACA,MAAM,SAAS,OAAO;MACtB,KAAK,SAAS,OAAO;MACrB,KAAK,SAAS,OAAO;MACrB,MAAM,SAAS,OAAO;;AAE1B,QAAI;AACJ,QAAI,CAAC,KAAK,SAAS,IAAI,QAAQ,GAAG;AAC9B,qBAAe,EAAE,SAAS,CAAA,EAAE;AAC5B,WAAK,SAAS,IAAI,UAAU,YAAY;IAC5C,OAAO;AACH,qBAAe,KAAK,SAAS,IAAI,QAAQ;IAC7C;AACA,QAAI,CAAC,aAAa,QAAQ;AACtB,YAAM,KAAK,OAAO,UAAU,QAAQ;AACpC,YAAM,YAAY,MAAM,KAAK,QAAQ,UAAU,UAAU,EAAE,MAAM,mCAAiB,CAAE;AACpF,UAAI,WAAW,UAAU,KAAK,SAAS,IAAI,UAAU,GAAG,GAAG;AACvD,qBAAa,SAAS;UAClB,KAAK,UAAU,OAAO;UACtB,KAAK,UAAU,OAAO;UACtB,MAAM,UAAU,OAAO;UACvB,MAAM,UAAU,OAAO;;MAE/B;IACJ;AACA,iBAAa,QAAQ,KAAK,WAAW;EACzC;;;;;;;;EASA,MAAM,qBAAqB,UAAkB,eAAwC;AACjF,QAAI,CAAC,KAAK,SAAS,IAAI,QAAQ,GAAG;AAC9B;IACJ;AACA,UAAM,QAAQ,KAAK,SAAS,IAAI,QAAQ;AACxC,UAAM,MAAM,OAAO,kBAAkB,WAAW,gBAAgB,MAAM,QAAQ,QAAQ,aAAa;AACnG,QAAI,QAAQ,IAAI;AACZ,YAAM,QAAQ,OAAO,KAAK,CAAC;AAC3B,UAAI,CAAC,MAAM,QAAQ,QAAQ;AACvB,aAAK,SAAS,OAAO,QAAQ;AAC7B,cAAM,KAAK,OAAO,YAAY,QAAQ;MAC1C;IACJ;EACJ;;",
+  "names": ["deepClone"]
+}

package/build/cjs/lib/adapter/managers/CertificateManager.d.ts

@@ -0,0 +1,50 @@
+import type { InternalGetCertificatesResult } from '../../_Types.js';
+import type { AdapterContext } from '../../../lib/adapter/context.js';
+import { AdapterContextBase } from '../../../lib/adapter/managers/AdapterContextBase.js';
+/** ID of the object holding all configured certificates */
+export declare const CERTIFICATES_OBJECT_ID = "system.certificates";
+/** Fetches SSL certificates from `system.certificates`, resolving file-backed values to their contents. */
+export declare class CertificateManager extends AdapterContextBase {
+    #private;
+    /**
+     * @param ctx Shared adapter context providing live runtime state
+     */
+    constructor(ctx: AdapterContext);
+    /**
+     * Tells whether a new version of the `system.certificates` object actually changes one of the
+     * certificates handed out by the last {@link getCertificates} call. Unrelated certificates being
+     * added, changed or removed are ignored, so that editing some other adapter's certificate does
+     * not restart this one.
+     *
+     * Compares the raw (unresolved) values: for a file-backed certificate that is the path, so
+     * repointing it to a different file counts as a change, while a change of the file content is
+     * left to the file watcher.
+     *
+     * @param obj the new `system.certificates` object, or null/undefined if it was deleted
+     */
+    hasRelevantChange(obj: ioBroker.OtherObject | null | undefined): boolean;
+    /**
+     * Forgets the certificates handed out by the last {@link getCertificates} call, so a subsequent
+     * change of `system.certificates` is no longer treated as relevant by {@link hasRelevantChange}.
+     * Used when the adapter stops watching its certificates.
+     */
+    stopWatching(): void;
+    /**
+     * Loads the named certificates from `system.certificates`. File-backed values (short strings that
+     * are existing paths) are read from disk and their paths collected in `certFilePaths` so the caller
+     * can watch them.
+     *
+     * @param names public/private/chained certificate names
+     * @param names.publicName Name of the public certificate
+     * @param names.privateName Name of the private key
+     * @param names.chainedName Name of the chained certificate
+     * @throws {Error} `ERROR_DB_CLOSED` when the objects database is not connected
+     * @throws {Error} `ERROR_NOT_FOUND` when the requested certificates are not configured
+     */
+    getCertificates(names: {
+        publicName?: string;
+        privateName?: string;
+        chainedName?: string;
+    }): Promise<InternalGetCertificatesResult>;
+}
+//# sourceMappingURL=CertificateManager.d.ts.map

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

@@ -0,0 +1,174 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CertificateManager_exports = {};
+__export(CertificateManager_exports, {
+  CERTIFICATES_OBJECT_ID: () => CERTIFICATES_OBJECT_ID,
+  CertificateManager: () => CertificateManager
+});
+module.exports = __toCommonJS(CertificateManager_exports);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_js_controller_common = require("@iobroker/js-controller-common");
+var import_AdapterContextBase = require("../../../lib/adapter/managers/AdapterContextBase.js");
+const CERTIFICATES_OBJECT_ID = "system.certificates";
+class CertificateManager extends import_AdapterContextBase.AdapterContextBase {
+  static {
+    __name(this, "CertificateManager");
+  }
+  /**
+   * Raw (unresolved) values of the certificates handed out by the last {@link getCertificates} call,
+   * keyed by certificate name. Used to tell a relevant change of `system.certificates` from an
+   * unrelated one. `undefined` until certificates have been requested at least once.
+   */
+  #usedCertificates;
+  /**
+   * @param ctx Shared adapter context providing live runtime state
+   */
+  constructor(ctx) {
+    super(ctx);
+  }
+  /**
+   * Tells whether a new version of the `system.certificates` object actually changes one of the
+   * certificates handed out by the last {@link getCertificates} call. Unrelated certificates being
+   * added, changed or removed are ignored, so that editing some other adapter's certificate does
+   * not restart this one.
+   *
+   * Compares the raw (unresolved) values: for a file-backed certificate that is the path, so
+   * repointing it to a different file counts as a change, while a change of the file content is
+   * left to the file watcher.
+   *
+   * @param obj the new `system.certificates` object, or null/undefined if it was deleted
+   */
+  hasRelevantChange(obj) {
+    const usedCertificates = this.#usedCertificates;
+    if (!usedCertificates) {
+      return false;
+    }
+    const certificates = obj?.native?.certificates;
+    for (const [name, value] of usedCertificates) {
+      if (certificates?.[name] !== value) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Forgets the certificates handed out by the last {@link getCertificates} call, so a subsequent
+   * change of `system.certificates` is no longer treated as relevant by {@link hasRelevantChange}.
+   * Used when the adapter stops watching its certificates.
+   */
+  stopWatching() {
+    this.#usedCertificates = void 0;
+  }
+  /**
+   * Loads the named certificates from `system.certificates`. File-backed values (short strings that
+   * are existing paths) are read from disk and their paths collected in `certFilePaths` so the caller
+   * can watch them.
+   *
+   * @param names public/private/chained certificate names
+   * @param names.publicName Name of the public certificate
+   * @param names.privateName Name of the private key
+   * @param names.chainedName Name of the chained certificate
+   * @throws {Error} `ERROR_DB_CLOSED` when the objects database is not connected
+   * @throws {Error} `ERROR_NOT_FOUND` when the requested certificates are not configured
+   */
+  async getCertificates(names) {
+    const { publicName, privateName, chainedName } = names;
+    const objects = this.objects;
+    let obj;
+    try {
+      obj = await objects.getObject(CERTIFICATES_OBJECT_ID);
+    } catch {
+    }
+    if (!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.`);
+      }
+      throw new Error(import_js_controller_common.tools.ERRORS.ERROR_NOT_FOUND);
+    }
+    const certFilePaths = new Array();
+    let ca;
+    if (chainedName) {
+      const chained = this.#resolveCert(obj.native.certificates[chainedName], certFilePaths).split("-----END CERTIFICATE-----\r\n");
+      if (chained.join("").length >= 512) {
+        const caArr = new Array();
+        for (const cert of chained) {
+          if (cert.replace(/(\r\n|\r|\n)/g, "").trim()) {
+            caArr.push(`${cert}-----END CERTIFICATE-----\r
+`);
+          }
+        }
+        ca = caArr.join("");
+      }
+    }
+    const certs = {
+      key: this.#resolveCert(obj.native.certificates[privateName], certFilePaths),
+      cert: this.#resolveCert(obj.native.certificates[publicName], certFilePaths),
+      ca
+    };
+    this.#usedCertificates = /* @__PURE__ */ new Map();
+    for (const name of [publicName, privateName, chainedName]) {
+      if (name) {
+        this.#usedCertificates.set(name, obj.native.certificates[name]);
+      }
+    }
+    return { certs, useLetsEncrypt: obj.native.letsEncrypt, certFilePaths };
+  }
+  /**
+   * Returns the certificate content. When `value` is a short string that is an existing file path,
+   * reads the file, records the path in `certFilePaths` (deduped), and returns the file content.
+   * Otherwise returns `value` unchanged.
+   *
+   * @param value inline certificate or a path to one
+   * @param certFilePaths accumulator for file-backed paths (mutated)
+   */
+  #resolveCert(value, certFilePaths) {
+    if (typeof value === "string") {
+      try {
+        if (value.length < 1024 && import_fs_extra.default.existsSync(value)) {
+          const content = import_fs_extra.default.readFileSync(value, "utf8");
+          if (!certFilePaths.includes(value)) {
+            certFilePaths.push(value);
+          }
+          return content;
+        }
+      } catch (e) {
+        this.logger.error(`${this.namespaceLog} Could not read certificate from file ${value}: ${e.message}`);
+      }
+    }
+    return value;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CERTIFICATES_OBJECT_ID,
+  CertificateManager
+});
+//# sourceMappingURL=CertificateManager.js.map

package/build/cjs/lib/adapter/managers/CertificateManager.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/lib/adapter/managers/CertificateManager.ts"],
+  "sourcesContent": ["import fs from 'fs-extra';\nimport { tools } from '@iobroker/js-controller-common';\nimport type { InternalGetCertificatesResult } from '../../_Types.js';\nimport type { AdapterContext } from '@/lib/adapter/context.js';\nimport { AdapterContextBase } from '@/lib/adapter/managers/AdapterContextBase.js';\n\n/** ID of the object holding all configured certificates */\nexport const CERTIFICATES_OBJECT_ID = 'system.certificates';\n\n/** Fetches SSL certificates from `system.certificates`, resolving file-backed values to their contents. */\nexport class CertificateManager extends AdapterContextBase {\n    /**\n     * Raw (unresolved) values of the certificates handed out by the last {@link getCertificates} call,\n     * keyed by certificate name. Used to tell a relevant change of `system.certificates` from an\n     * unrelated one. `undefined` until certificates have been requested at least once.\n     */\n    #usedCertificates?: Map<string, string>;\n\n    /**\n     * @param ctx Shared adapter context providing live runtime state\n     */\n    constructor(ctx: AdapterContext) {\n        super(ctx);\n    }\n\n    /**\n     * Tells whether a new version of the `system.certificates` object actually changes one of the\n     * certificates handed out by the last {@link getCertificates} call. Unrelated certificates being\n     * added, changed or removed are ignored, so that editing some other adapter's certificate does\n     * not restart this one.\n     *\n     * Compares the raw (unresolved) values: for a file-backed certificate that is the path, so\n     * repointing it to a different file counts as a change, while a change of the file content is\n     * left to the file watcher.\n     *\n     * @param obj the new `system.certificates` object, or null/undefined if it was deleted\n     */\n    hasRelevantChange(obj: ioBroker.OtherObject | null | undefined): boolean {\n        const usedCertificates = this.#usedCertificates;\n        if (!usedCertificates) {\n            // certificates were never requested, so nothing can have changed for us\n            return false;\n        }\n\n        const certificates: Record<string, string> | undefined = obj?.native?.certificates;\n\n        for (const [name, value] of usedCertificates) {\n            if (certificates?.[name] !== value) {\n                return true;\n            }\n        }\n\n        return false;\n    }\n\n    /**\n     * Forgets the certificates handed out by the last {@link getCertificates} call, so a subsequent\n     * change of `system.certificates` is no longer treated as relevant by {@link hasRelevantChange}.\n     * Used when the adapter stops watching its certificates.\n     */\n    stopWatching(): void {\n        this.#usedCertificates = undefined;\n    }\n\n    /**\n     * Loads the named certificates from `system.certificates`. File-backed values (short strings that\n     * are existing paths) are read from disk and their paths collected in `certFilePaths` so the caller\n     * can watch them.\n     *\n     * @param names public/private/chained certificate names\n     * @param names.publicName Name of the public certificate\n     * @param names.privateName Name of the private key\n     * @param names.chainedName Name of the chained certificate\n     * @throws {Error} `ERROR_DB_CLOSED` when the objects database is not connected\n     * @throws {Error} `ERROR_NOT_FOUND` when the requested certificates are not configured\n     */\n    async getCertificates(names: {\n        publicName?: string;\n        privateName?: string;\n        chainedName?: string;\n    }): Promise<InternalGetCertificatesResult> {\n        const { publicName, privateName, chainedName } = names;\n        const objects = this.objects;\n\n        let obj: ioBroker.OtherObject | undefined | null;\n        try {\n            obj = await objects.getObject(CERTIFICATES_OBJECT_ID);\n        } catch {\n            // ignore\n        }\n\n        if (\n            !obj?.native.certificates ||\n            !publicName ||\n            !privateName ||\n            !obj.native.certificates[publicName] ||\n            !obj.native.certificates[privateName] ||\n            (chainedName && !obj.native.certificates[chainedName])\n        ) {\n            this.logger.error(\n                `${this.namespaceLog} Cannot configure secure web server, because no certificates found: ${publicName}, ${privateName}, ${chainedName}`,\n            );\n            if (publicName === 'defaultPublic' || privateName === 'defaultPrivate') {\n                this.logger.info(\n                    `${this.namespaceLog} Default certificates seem to be configured but missing. You can execute \"iobroker cert create\" in your shell to create these.`,\n                );\n            }\n            throw new Error(tools.ERRORS.ERROR_NOT_FOUND);\n        }\n\n        const certFilePaths = new Array<string>();\n\n        let ca: string | undefined;\n        if (chainedName) {\n            const chained = this.#resolveCert(obj.native.certificates[chainedName], certFilePaths).split(\n                '-----END CERTIFICATE-----\\r\\n',\n            );\n            if (chained.join('').length >= 512) {\n                const caArr = new Array<string>();\n                for (const cert of chained) {\n                    if (cert.replace(/(\\r\\n|\\r|\\n)/g, '').trim()) {\n                        caArr.push(`${cert}-----END CERTIFICATE-----\\r\\n`);\n                    }\n                }\n                ca = caArr.join('');\n            }\n        }\n\n        const certs: ioBroker.Certificates = {\n            key: this.#resolveCert(obj.native.certificates[privateName], certFilePaths),\n            cert: this.#resolveCert(obj.native.certificates[publicName], certFilePaths),\n            ca,\n        };\n\n        // remember the raw values, so a change of `system.certificates` can be told from an unrelated one\n        this.#usedCertificates = new Map<string, string>();\n        for (const name of [publicName, privateName, chainedName]) {\n            if (name) {\n                this.#usedCertificates.set(name, obj.native.certificates[name]);\n            }\n        }\n\n        return { certs, useLetsEncrypt: obj.native.letsEncrypt, certFilePaths };\n    }\n\n    /**\n     * Returns the certificate content. When `value` is a short string that is an existing file path,\n     * reads the file, records the path in `certFilePaths` (deduped), and returns the file content.\n     * Otherwise returns `value` unchanged.\n     *\n     * @param value inline certificate or a path to one\n     * @param certFilePaths accumulator for file-backed paths (mutated)\n     */\n    #resolveCert(value: string, certFilePaths: string[]): string {\n        if (typeof value === 'string') {\n            try {\n                if (value.length < 1024 && fs.existsSync(value)) {\n                    const content = fs.readFileSync(value, 'utf8');\n                    if (!certFilePaths.includes(value)) {\n                        certFilePaths.push(value);\n                    }\n                    return content;\n                }\n            } catch (e: any) {\n                this.logger.error(`${this.namespaceLog} Could not read certificate from file ${value}: ${e.message}`);\n            }\n        }\n        return value;\n    }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;AAAA,sBAAe;AACf,kCAAsB;AAGtB,gCAAmC;AAG5B,MAAM,yBAAyB;AAGhC,MAAO,2BAA2B,6CAAkB;EAV1D,OAU0D;;;;;;;;EAMtD;;;;EAKA,YAAY,KAAmB;AAC3B,UAAM,GAAG;EACb;;;;;;;;;;;;;EAcA,kBAAkB,KAA4C;AAC1D,UAAM,mBAAmB,KAAK;AAC9B,QAAI,CAAC,kBAAkB;AAEnB,aAAO;IACX;AAEA,UAAM,eAAmD,KAAK,QAAQ;AAEtE,eAAW,CAAC,MAAM,KAAK,KAAK,kBAAkB;AAC1C,UAAI,eAAe,IAAI,MAAM,OAAO;AAChC,eAAO;MACX;IACJ;AAEA,WAAO;EACX;;;;;;EAOA,eAAY;AACR,SAAK,oBAAoB;EAC7B;;;;;;;;;;;;;EAcA,MAAM,gBAAgB,OAIrB;AACG,UAAM,EAAE,YAAY,aAAa,YAAW,IAAK;AACjD,UAAM,UAAU,KAAK;AAErB,QAAI;AACJ,QAAI;AACA,YAAM,MAAM,QAAQ,UAAU,sBAAsB;IACxD,QAAQ;IAER;AAEA,QACI,CAAC,KAAK,OAAO,gBACb,CAAC,cACD,CAAC,eACD,CAAC,IAAI,OAAO,aAAa,UAAU,KACnC,CAAC,IAAI,OAAO,aAAa,WAAW,KACnC,eAAe,CAAC,IAAI,OAAO,aAAa,WAAW,GACtD;AACE,WAAK,OAAO,MACR,GAAG,KAAK,YAAY,uEAAuE,UAAU,KAAK,WAAW,KAAK,WAAW,EAAE;AAE3I,UAAI,eAAe,mBAAmB,gBAAgB,kBAAkB;AACpE,aAAK,OAAO,KACR,GAAG,KAAK,YAAY,gIAAgI;MAE5J;AACA,YAAM,IAAI,MAAM,kCAAM,OAAO,eAAe;IAChD;AAEA,UAAM,gBAAgB,IAAI,MAAK;AAE/B,QAAI;AACJ,QAAI,aAAa;AACb,YAAM,UAAU,KAAK,aAAa,IAAI,OAAO,aAAa,WAAW,GAAG,aAAa,EAAE,MACnF,+BAA+B;AAEnC,UAAI,QAAQ,KAAK,EAAE,EAAE,UAAU,KAAK;AAChC,cAAM,QAAQ,IAAI,MAAK;AACvB,mBAAW,QAAQ,SAAS;AACxB,cAAI,KAAK,QAAQ,iBAAiB,EAAE,EAAE,KAAI,GAAI;AAC1C,kBAAM,KAAK,GAAG,IAAI;CAA+B;UACrD;QACJ;AACA,aAAK,MAAM,KAAK,EAAE;MACtB;IACJ;AAEA,UAAM,QAA+B;MACjC,KAAK,KAAK,aAAa,IAAI,OAAO,aAAa,WAAW,GAAG,aAAa;MAC1E,MAAM,KAAK,aAAa,IAAI,OAAO,aAAa,UAAU,GAAG,aAAa;MAC1E;;AAIJ,SAAK,oBAAoB,oBAAI,IAAG;AAChC,eAAW,QAAQ,CAAC,YAAY,aAAa,WAAW,GAAG;AACvD,UAAI,MAAM;AACN,aAAK,kBAAkB,IAAI,MAAM,IAAI,OAAO,aAAa,IAAI,CAAC;MAClE;IACJ;AAEA,WAAO,EAAE,OAAO,gBAAgB,IAAI,OAAO,aAAa,cAAa;EACzE;;;;;;;;;EAUA,aAAa,OAAe,eAAuB;AAC/C,QAAI,OAAO,UAAU,UAAU;AAC3B,UAAI;AACA,YAAI,MAAM,SAAS,QAAQ,gBAAAA,QAAG,WAAW,KAAK,GAAG;AAC7C,gBAAM,UAAU,gBAAAA,QAAG,aAAa,OAAO,MAAM;AAC7C,cAAI,CAAC,cAAc,SAAS,KAAK,GAAG;AAChC,0BAAc,KAAK,KAAK;UAC5B;AACA,iBAAO;QACX;MACJ,SAAS,GAAQ;AACb,aAAK,OAAO,MAAM,GAAG,KAAK,YAAY,yCAAyC,KAAK,KAAK,EAAE,OAAO,EAAE;MACxG;IACJ;AACA,WAAO;EACX;;",
+  "names": ["fs"]
+}

package/build/cjs/lib/adapter/managers/MessagingManager.d.ts

@@ -0,0 +1,58 @@
+import type { InternalSendToHostOptions, InternalSendToOptions, NotificationOptions, SendToUserInterfaceClientOptions } from '../../_Types.js';
+import type { AdapterContext } from '../../../lib/adapter/context.js';
+import { AdapterContextBase } from '../../../lib/adapter/managers/AdapterContextBase.js';
+/** Owns the adapter's outbound messaging and the pending-reply registry. */
+export declare class MessagingManager extends AdapterContextBase {
+    #private;
+    /**
+     * @param ctx Shared adapter context providing live runtime state
+     */
+    constructor(ctx: AdapterContext);
+    /**
+     * Sends a message to another adapter instance.
+     *
+     * When `opts.expectReply` is true and the target is a specific instance (not broadcast),
+     * the returned promise resolves with the reply message when it arrives, or rejects with
+     * `Error('Timeout exceeded')` if `opts.options.timeout` elapses.
+     *
+     * @param opts Normalized send options
+     */
+    sendTo(opts: InternalSendToOptions): Promise<any>;
+    /**
+     * Sends a message to a host, or broadcasts to all hosts when `hostName` is `null`.
+     *
+     * When `opts.expectReply` is true and a specific host is targeted, the returned promise
+     * resolves with the reply message when it arrives, or rejects with `Error('Timeout exceeded')`
+     * if `opts.options.timeout` elapses. Broadcasts (hostName === null) resolve void.
+     *
+     * @param opts Normalized send options
+     */
+    sendToHost(opts: InternalSendToHostOptions): Promise<any>;
+    /**
+     * Resolves a pending reply promise for an acked messagebox message.
+     * Returns true if a pending entry was found and consumed.
+     *
+     * @param obj incoming message object from the messagebox
+     */
+    resolveCallback(obj: ioBroker.Message): boolean;
+    /**
+     * Rejects all pending reply promises and clears their timers (used on stop).
+     */
+    clearPendingCallbacks(): void;
+    /**
+     * Sends a message to a single UI client, or broadcasts to all connected UI clients when `clientId` is omitted.
+     *
+     * @param options clientId and data options
+     */
+    sendToUI(options: SendToUserInterfaceClientOptions): Promise<void>;
+    /**
+     * Sends an addNotification command to the host of this adapter instance.
+     *
+     * @param scope notification scope
+     * @param category notification category, or `null` to match by scope regex
+     * @param message notification message
+     * @param options additional notification options
+     */
+    registerNotification(scope: string, category: string | null, message: string, options?: NotificationOptions): Promise<void>;
+}
+//# sourceMappingURL=MessagingManager.d.ts.map

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

@@ -0,0 +1,289 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MessagingManager_exports = {};
+__export(MessagingManager_exports, {
+  MessagingManager: () => MessagingManager
+});
+module.exports = __toCommonJS(MessagingManager_exports);
+var import_AdapterContextBase = require("../../../lib/adapter/managers/AdapterContextBase.js");
+var import_utils = require("../../../lib/adapter/utils.js");
+class MessagingManager extends import_AdapterContextBase.AdapterContextBase {
+  static {
+    __name(this, "MessagingManager");
+  }
+  #pending = /* @__PURE__ */ new Map();
+  #callbackId = 1;
+  #mboxSubscribed = false;
+  /**
+   * @param ctx Shared adapter context providing live runtime state
+   */
+  constructor(ctx) {
+    super(ctx);
+  }
+  /**
+   * Sends a message to another adapter instance.
+   *
+   * When `opts.expectReply` is true and the target is a specific instance (not broadcast),
+   * the returned promise resolves with the reply message when it arrives, or rejects with
+   * `Error('Timeout exceeded')` if `opts.options.timeout` elapses.
+   *
+   * @param opts Normalized send options
+   */
+  async sendTo(opts) {
+    const { command, message, callback, options, expectReply } = opts;
+    let { instanceName } = opts;
+    if (!instanceName) {
+      throw new Error("No instanceName provided or not a string");
+    }
+    if (!instanceName.startsWith("system.adapter.")) {
+      instanceName = `system.adapter.${instanceName}`;
+    }
+    const obj = {
+      command,
+      message,
+      from: `system.adapter.${this.namespace}`
+    };
+    const states = this.states;
+    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]+$/)) {
+      const objects = this.objects;
+      const res = await objects.getObjectView("system", "instance", {
+        startkey: `${instanceName}.`,
+        endkey: `${instanceName}.\u9999`
+      }).catch(() => void 0);
+      if (res) {
+        for (const row of res.rows) {
+          await states.pushMessage(row.id, obj);
+        }
+      }
+      return;
+    }
+    if (expectReply) {
+      return this.#registerReply(states, instanceName, obj, options);
+    }
+    if (callback) {
+      obj.callback = { ...callback, ack: true };
+    }
+    await states.pushMessage(instanceName, obj);
+  }
+  /**
+   * Subscribes to this instance's messagebox on demand when the adapter does not advertise
+   * messagebox support, so replies to outbound messages are received. Idempotent.
+   *
+   * @param states the connected states DB client
+   */
+  #maybeSubscribe(states) {
+    const common = this.common;
+    if (common && !(0, import_utils.isMessageboxSupported)(common) && !this.#mboxSubscribed) {
+      this.#mboxSubscribed = true;
+      states.subscribeMessage(`system.adapter.${this.namespace}`).catch((e) => this.logger.error(`${this.namespaceLog} Cannot subscribe to messages: ${e.message}`));
+    }
+  }
+  /**
+   * Sets a reply callback header on `obj`, registers a pending-reply resolver keyed by its id,
+   * subscribes the messagebox on demand, pushes the message and returns a promise that resolves
+   * with the reply once `resolveCallback` is invoked for the matching id, or rejects with
+   * `Error('Timeout exceeded')` when `options.timeout` elapses.
+   *
+   * @param states the connected states DB client
+   * @param target the recipient id (instance or host) for `pushMessage`
+   * @param obj the message to send; its `callback` header is set here
+   * @param options additional send options (e.g. timeout)
+   */
+  async #registerReply(states, target, obj, options) {
+    this.#maybeSubscribe(states);
+    const id = this.#callbackId++;
+    if (this.#callbackId >= 4294967295) {
+      this.#callbackId = 1;
+    }
+    obj.callback = {
+      message: obj.message,
+      id,
+      ack: false,
+      time: Date.now()
+    };
+    let pendingEntry;
+    const replyPromise = new Promise((resolve, reject) => {
+      let timer;
+      if (options?.timeout) {
+        timer = setTimeout(() => {
+          if (this.#pending.has(id)) {
+            this.#pending.delete(id);
+            reject(new Error("Timeout exceeded"));
+          }
+        }, options.timeout);
+      }
+      pendingEntry = { resolve, reject, timer, time: Date.now() };
+      this.#pending.set(id, pendingEntry);
+    });
+    const now = Date.now();
+    for (const [_id, entry] of this.#pending) {
+      if (now - entry.time > 36e5) {
+        this.#pending.delete(_id);
+      }
+    }
+    try {
+      await states.pushMessage(target, obj);
+    } catch (e) {
+      if (pendingEntry.timer) {
+        clearTimeout(pendingEntry.timer);
+      }
+      this.#pending.delete(id);
+      throw e;
+    }
+    return replyPromise;
+  }
+  /**
+   * Sends a message to a host, or broadcasts to all hosts when `hostName` is `null`.
+   *
+   * When `opts.expectReply` is true and a specific host is targeted, the returned promise
+   * resolves with the reply message when it arrives, or rejects with `Error('Timeout exceeded')`
+   * if `opts.options.timeout` elapses. Broadcasts (hostName === null) resolve void.
+   *
+   * @param opts Normalized send options
+   */
+  async sendToHost(opts) {
+    const { command, message, expectReply, options, callback } = opts;
+    let { hostName } = opts;
+    const obj = {
+      command,
+      message,
+      from: `system.adapter.${this.namespace}`
+    };
+    const states = this.states;
+    if (hostName && !hostName.startsWith("system.host.")) {
+      hostName = `system.host.${hostName}`;
+    }
+    if (!hostName) {
+      const objects = this.objects;
+      const res = await objects.getObjectList({ startkey: "system.host.", endkey: "system.host.\u9999" });
+      if (res?.rows.length) {
+        for (const row of res.rows) {
+          const parts = row.id.split(".");
+          if (parts.length === 3) {
+            await states.pushMessage(row.id, obj);
+          }
+        }
+      }
+      return;
+    }
+    if (expectReply) {
+      return this.#registerReply(states, hostName, obj, options);
+    }
+    if (callback) {
+      obj.callback = { ...callback, ack: true };
+    }
+    await states.pushMessage(hostName, obj);
+  }
+  /**
+   * Resolves a pending reply promise for an acked messagebox message.
+   * Returns true if a pending entry was found and consumed.
+   *
+   * @param obj incoming message object from the messagebox
+   */
+  resolveCallback(obj) {
+    if (!obj.callback?.ack || !obj.callback.id) {
+      return false;
+    }
+    const entry = this.#pending.get(obj.callback.id);
+    if (!entry) {
+      return false;
+    }
+    if (entry.timer) {
+      clearTimeout(entry.timer);
+    }
+    this.#pending.delete(obj.callback.id);
+    entry.resolve(obj.message);
+    const now = Date.now();
+    for (const [id, pending] of this.#pending) {
+      if (now - pending.time > 36e5) {
+        this.#pending.delete(id);
+      }
+    }
+    return true;
+  }
+  /**
+   * Rejects all pending reply promises and clears their timers (used on stop).
+   */
+  clearPendingCallbacks() {
+    if (this.#pending.size) {
+      const err = new Error("Adapter stopped");
+      for (const entry of this.#pending.values()) {
+        if (entry.timer) {
+          clearTimeout(entry.timer);
+        }
+        entry.reject(err);
+      }
+      this.#pending.clear();
+    }
+  }
+  /**
+   * Sends a message to a single UI client, or broadcasts to all connected UI clients when `clientId` is omitted.
+   *
+   * @param options clientId and data options
+   */
+  sendToUI(options) {
+    const states = this.states;
+    const { clientId, data } = options;
+    if (clientId === void 0) {
+      return this.uiMessagingController.sendToAllClients({
+        data,
+        states
+      });
+    }
+    return this.uiMessagingController.sendToClient({
+      clientId,
+      data,
+      states
+    });
+  }
+  /**
+   * Sends an addNotification command to the host of this adapter instance.
+   *
+   * @param scope notification scope
+   * @param category notification category, or `null` to match by scope regex
+   * @param message notification message
+   * @param options additional notification options
+   */
+  async registerNotification(scope, category, message, options) {
+    const states = this.states;
+    const obj = {
+      command: "addNotification",
+      message: {
+        scope,
+        category,
+        message,
+        instance: this.namespace,
+        contextData: options?.contextData
+      },
+      from: `system.adapter.${this.namespace}`
+    };
+    await states.pushMessage(`system.host.${this.host}`, obj);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MessagingManager
+});
+//# sourceMappingURL=MessagingManager.js.map