@smarthome.exchange/integrations 1.0.0 → 3.0.0

package/dist_ts/integrations/yamaha/yamaha.mapper.js

@@ -1,20 +1,66 @@
-import { SimpleLocalMapper } from '../../core/index.js';
+import { SimpleLocalMapper } from '../../core/classes.simplelocalintegration.js';
 import { yamahaProfile } from './yamaha.types.js';
 export class YamahaMapper {
-    static toSnapshot(optionsArg) {
-        return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: yamahaProfile });
+    static deviceId(homeId, deviceId) {
+        return `yamaha.receiver.${encodeURIComponent(homeId)}.${encodeURIComponent(deviceId)}`;
     }
-    static toSnapshotFromRaw(configArg, rawDataArg) {
-        return SimpleLocalMapper.toSnapshot({ profile: yamahaProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+    static entityId(homeId, deviceId) {
+        return `media_player.yamaha.${encodeURIComponent(homeId)}.${encodeURIComponent(deviceId)}`;
     }
-    static toDevices(snapshotArg) {
-        return SimpleLocalMapper.toDevices(yamahaProfile, snapshotArg);
+    static toDevices(snapshot) {
+        return [{
+                id: this.deviceId(snapshot.homeId, snapshot.identity.deviceId), integrationDomain: 'yamaha', name: snapshot.name,
+                protocol: 'http', manufacturer: 'Yamaha', model: snapshot.identity.model, online: true,
+                features: [
+                    { id: 'power', capability: 'media', name: 'Main-zone power', readable: true, writable: true },
+                    { id: 'muted', capability: 'media', name: 'Main-zone mute', readable: true, writable: true },
+                    { id: 'volume_raw', capability: 'media', name: 'Main-zone absolute vendor volume', unit: 'raw', readable: true, writable: true },
+                    { id: 'input', capability: 'media', name: 'Main-zone input', readable: true, writable: snapshot.inputs.length > 0 },
+                ],
+                state: [
+                    { featureId: 'power', value: snapshot.power === 'on', updatedAt: snapshot.observedAt },
+                    { featureId: 'muted', value: snapshot.muted, updatedAt: snapshot.observedAt },
+                    { featureId: 'volume_raw', value: snapshot.volume, updatedAt: snapshot.observedAt },
+                    { featureId: 'input', value: snapshot.input, updatedAt: snapshot.observedAt },
+                ],
+                metadata: { homeId: snapshot.homeId, deviceId: snapshot.identity.deviceId, origin: snapshot.origin, zone: 'main',
+                    apiVersion: snapshot.identity.apiVersion, inputs: [...snapshot.inputs], volumeRange: { ...snapshot.volumeRange },
+                    ownerMaxVolume: snapshot.ownerMaxVolume, receiverMaxVolume: snapshot.receiverMaxVolume,
+                    stateSource: 'receiver-observation', identityAuthentication: 'unauthenticated-lan' },
+            }];
     }
-    static toEntities(snapshotArg) {
-        return SimpleLocalMapper.toEntities(yamahaProfile, snapshotArg);
+    static toEntities(snapshot) {
+        return [{
+                id: this.entityId(snapshot.homeId, snapshot.identity.deviceId), uniqueId: this.deviceId(snapshot.homeId, snapshot.identity.deviceId),
+                integrationDomain: 'yamaha', deviceId: this.deviceId(snapshot.homeId, snapshot.identity.deviceId), platform: 'media_player',
+                name: snapshot.name, state: snapshot.power === 'on' ? 'on' : 'off', available: true,
+                attributes: { homeId: snapshot.homeId, deviceId: snapshot.identity.deviceId, zone: 'main', power: snapshot.power,
+                    volumeRaw: snapshot.volume, volumeUnit: 'raw', muted: snapshot.muted, source: snapshot.input, sourceList: [...snapshot.inputs],
+                    volumeRange: { ...snapshot.volumeRange }, ownerMaxVolume: snapshot.ownerMaxVolume, receiverMaxVolume: snapshot.receiverMaxVolume,
+                    observedAt: snapshot.observedAt, stateSource: 'receiver-observation' },
+            }];
     }
-    static slug(valueArg) {
-        return SimpleLocalMapper.slug(valueArg);
+}
+/** The former generic mapping remains available without admitting data as a live device. */
+export class YamahaOfflineMapper {
+    static toSnapshot(options) {
+        const snapshot = SimpleLocalMapper.toSnapshot({ ...options, profile: yamahaProfile, online: false });
+        return { ...snapshot, online: false, source: 'manual',
+            entities: snapshot.entities.map((entity) => ({ ...entity, available: false, writable: false })),
+            capabilities: { localRead: false, localControl: false, offlineData: true } };
+    }
+    static toSnapshotFromRaw(config, rawData) {
+        return this.toSnapshot({ config, rawData, source: 'manual' });
+    }
+    static toDevices(snapshot) {
+        return SimpleLocalMapper.toDevices(yamahaProfile, snapshot).map((device) => ({ ...device, online: false,
+            features: device.features.map((feature) => ({ ...feature, writable: false })),
+            metadata: { ...device.metadata, stateSource: 'explicit-offline-data' } }));
+    }
+    static toEntities(snapshot) {
+        return SimpleLocalMapper.toEntities(yamahaProfile, snapshot).map((entity) => ({ ...entity, available: false,
+            attributes: { ...entity.attributes, stateSource: 'explicit-offline-data' } }));
     }
+    static slug(value) { return SimpleLocalMapper.slug(value); }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieWFtYWhhLm1hcHBlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy95YW1haGEveWFtYWhhLm1hcHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsaUJBQWlCLEVBQWtILE1BQU0scUJBQXFCLENBQUM7QUFFeEssT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRWxELE1BQU0sT0FBTyxZQUFZO0lBQ2hCLE1BQU0sQ0FBQyxVQUFVLENBQUMsVUFBdUU7UUFDOUYsT0FBTyxpQkFBaUIsQ0FBQyxVQUFVLENBQUMsRUFBRSxHQUFHLFVBQVUsRUFBRSxPQUFPLEVBQUUsYUFBYSxFQUFFLENBQUMsQ0FBQztJQUNqRixDQUFDO0lBRU0sTUFBTSxDQUFDLGlCQUFpQixDQUFDLFNBQXdCLEVBQUUsVUFBK0I7UUFDdkYsT0FBTyxpQkFBaUIsQ0FBQyxVQUFVLENBQUMsRUFBRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFDO0lBQzFJLENBQUM7SUFFTSxNQUFNLENBQUMsU0FBUyxDQUFDLFdBQWlDO1FBQ3ZELE9BQU8saUJBQWlCLENBQUMsU0FBUyxDQUFDLGFBQWEsRUFBRSxXQUFXLENBQUMsQ0FBQztJQUNqRSxDQUFDO0lBRU0sTUFBTSxDQUFDLFVBQVUsQ0FBQyxXQUFpQztRQUN4RCxPQUFPLGlCQUFpQixDQUFDLFVBQVUsQ0FBQyxhQUFhLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFDbEUsQ0FBQztJQUVNLE1BQU0sQ0FBQyxJQUFJLENBQUMsUUFBaUI7UUFDbEMsT0FBTyxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDMUMsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/yamaha/yamaha.types.d.ts

@@ -1,11 +1,78 @@
-import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/classes.simplelocalintegration.js';
 export declare const yamahaDomain = "yamaha";
-export declare const yamahaDefaultName = "Yamaha Network Receivers";
-export type TYamahaRawData = TSimpleLocalRawData;
-export interface IYamahaSnapshot extends ISimpleLocalSnapshot {
-}
-export interface IYamahaConfig extends ISimpleLocalConfig {
+export declare const yamahaDefaultName = "Yamaha RX-V485 main zone";
+export type TYamahaModel = 'RX-V485';
+export interface IYamahaConfig {
+    homeId: string;
+    origin: string;
+    expectedDeviceId: string;
+    model: TYamahaModel;
+    allowUnencryptedHttp: true;
+    maxVolume: number;
+    name?: string;
+    timeoutMs?: number;
+    maxResponseBytes?: number;
+    maxPendingOperations?: number;
 }
 export interface IHomeAssistantYamahaConfig extends IYamahaConfig {
 }
+export interface IYamahaIdentity {
+    readonly deviceId: string;
+    readonly model: TYamahaModel;
+    readonly apiVersion: number;
+}
+export interface IYamahaVolumeRange {
+    readonly min: number;
+    readonly max: number;
+    readonly step: number;
+}
+/** Receiver settings are observations, without claims about an electrical or acoustic effect. */
+export interface IYamahaSnapshot {
+    readonly homeId: string;
+    readonly origin: string;
+    readonly name: string;
+    readonly identity: IYamahaIdentity;
+    readonly power: 'on' | 'standby';
+    readonly muted: boolean;
+    readonly volume: number;
+    readonly receiverMaxVolume: number;
+    readonly ownerMaxVolume: number;
+    readonly input: string;
+    readonly inputs: readonly string[];
+    readonly volumeRange: IYamahaVolumeRange;
+    readonly observedAt: string;
+}
+export type TYamahaControl = {
+    feature: 'power';
+    value: boolean;
+} | {
+    feature: 'muted';
+    value: boolean;
+} | {
+    feature: 'volume_raw';
+    value: number;
+} | {
+    feature: 'input';
+    value: string;
+};
+export interface IYamahaEffectResult {
+    readonly dispatch: 'acknowledged';
+    readonly outcome: 'observed-target' | 'indeterminate';
+    readonly snapshot: IYamahaSnapshot;
+}
+export interface IYamahaManualEntry {
+    origin?: string;
+    expectedDeviceId?: string;
+    id?: string;
+    model?: string;
+    name?: string;
+    manufacturer?: string;
+    metadata?: Record<string, unknown>;
+}
+export type TYamahaRawData = TSimpleLocalRawData;
+export interface IYamahaOfflineConfig extends ISimpleLocalConfig {
+}
+export interface IYamahaOfflineSnapshot extends ISimpleLocalSnapshot {
+}
+/** Pure offline mapping profile; it supplies no protocol client or live runtime admission. */
 export declare const yamahaProfile: ISimpleLocalIntegrationProfile;

package/dist_ts/integrations/yamaha/yamaha.types.js

@@ -1,96 +1,10 @@
-export const yamahaDomain = "yamaha";
-export const yamahaDefaultName = "Yamaha Network Receivers";
+export const yamahaDomain = 'yamaha';
+export const yamahaDefaultName = 'Yamaha RX-V485 main zone';
+/** Pure offline mapping profile; it supplies no protocol client or live runtime admission. */
 export const yamahaProfile = {
-    domain: "yamaha",
-    displayName: "Yamaha Network Receivers",
-    manufacturer: "Yamaha",
-    model: "Network receiver",
-    defaultName: "Yamaha Network Receivers",
-    defaultPort: 80,
-    defaultHttpPath: "/YamahaRemoteControl/ctrl",
-    defaultProtocol: "http",
-    status: "control-runtime",
-    platforms: [
-        "media_player",
-        "sensor"
-    ],
-    serviceDomains: [
-        "media_player"
-    ],
-    controlServices: [
-        "turn_on",
-        "turn_off",
-        "volume_up",
-        "volume_down",
-        "volume_mute",
-        "select_source",
-        "media_play",
-        "media_pause",
-        "media_stop",
-        "media_next_track",
-        "media_previous_track"
-    ],
-    discoverySources: [
-        "manual",
-        "mdns",
-        "ssdp",
-        "http",
-        "custom"
-    ],
-    discoveryKeywords: [
-        "yamaha",
-        "rx-v",
-        "receiver"
-    ],
-    metadata: {
-        source: "home-assistant/core",
-        upstreamPath: "homeassistant/components/yamaha",
-        upstreamDomain: "yamaha",
-        iotClass: "local_polling",
-        qualityScale: "legacy",
-        requirements: [
-            "rxv==0.7.0"
-        ],
-        dependencies: [],
-        afterDependencies: [],
-        codeowners: [],
-        configFlow: true,
-        runtime: {
-            type: "control-runtime",
-            services: [
-                "snapshot",
-                "status",
-                "refresh",
-                "turn_on",
-                "turn_off",
-                "volume_up",
-                "volume_down",
-                "volume_mute",
-                "select_source",
-                "media_play",
-                "media_pause",
-                "media_stop",
-                "media_next_track",
-                "media_previous_track"
-            ],
-            platforms: [
-                "media_player",
-                "sensor"
-            ],
-            controls: true
-        },
-        localApi: {
-            implemented: [
-                "manual local endpoint setup",
-                "snapshot, raw data, snapshotProvider, and injected native client operation",
-                "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
-            ],
-            explicitUnsupported: [
-                "claiming live command success without injected client.execute or commandExecutor",
-                "cloud account flows and remote API polling",
-                "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
-            ]
-        }
-    }
+    domain: yamahaDomain, displayName: 'Yamaha offline data', manufacturer: 'Yamaha', model: 'Unverified Yamaha receiver',
+    defaultName: 'Yamaha offline data', defaultProtocol: 'unknown', status: 'read-only-runtime',
+    platforms: ['media_player', 'sensor'], serviceDomains: [], controlServices: [],
+    discoverySources: [], discoveryKeywords: [], metadata: { source: 'explicit-offline-data', liveRuntime: false },
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieWFtYWhhLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL3lhbWFoYS95YW1haGEudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLFFBQVEsQ0FBQztBQUNyQyxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRywwQkFBMEIsQ0FBQztBQU81RCxNQUFNLENBQUMsTUFBTSxhQUFhLEdBQW1DO0lBQzNELE1BQU0sRUFBRSxRQUFRO0lBQ2hCLFdBQVcsRUFBRSwwQkFBMEI7SUFDdkMsWUFBWSxFQUFFLFFBQVE7SUFDdEIsS0FBSyxFQUFFLGtCQUFrQjtJQUN6QixXQUFXLEVBQUUsMEJBQTBCO0lBQ3ZDLFdBQVcsRUFBRSxFQUFFO0lBQ2YsZUFBZSxFQUFFLDJCQUEyQjtJQUM1QyxlQUFlLEVBQUUsTUFBTTtJQUN2QixNQUFNLEVBQUUsaUJBQWlCO0lBQ3pCLFNBQVMsRUFBRTtRQUNULGNBQWM7UUFDZCxRQUFRO0tBQ1Q7SUFDRCxjQUFjLEVBQUU7UUFDZCxjQUFjO0tBQ2Y7SUFDRCxlQUFlLEVBQUU7UUFDZixTQUFTO1FBQ1QsVUFBVTtRQUNWLFdBQVc7UUFDWCxhQUFhO1FBQ2IsYUFBYTtRQUNiLGVBQWU7UUFDZixZQUFZO1FBQ1osYUFBYTtRQUNiLFlBQVk7UUFDWixrQkFBa0I7UUFDbEIsc0JBQXNCO0tBQ3ZCO0lBQ0QsZ0JBQWdCLEVBQUU7UUFDaEIsUUFBUTtRQUNSLE1BQU07UUFDTixNQUFNO1FBQ04sTUFBTTtRQUNOLFFBQVE7S0FDVDtJQUNELGlCQUFpQixFQUFFO1FBQ2pCLFFBQVE7UUFDUixNQUFNO1FBQ04sVUFBVTtLQUNYO0lBQ0QsUUFBUSxFQUFFO1FBQ1IsTUFBTSxFQUFFLHFCQUFxQjtRQUM3QixZQUFZLEVBQUUsaUNBQWlDO1FBQy9DLGNBQWMsRUFBRSxRQUFRO1FBQ3hCLFFBQVEsRUFBRSxlQUFlO1FBQ3pCLFlBQVksRUFBRSxRQUFRO1FBQ3RCLFlBQVksRUFBRTtZQUNaLFlBQVk7U0FDYjtRQUNELFlBQVksRUFBRSxFQUFFO1FBQ2hCLGlCQUFpQixFQUFFLEVBQUU7UUFDckIsVUFBVSxFQUFFLEVBQUU7UUFDZCxVQUFVLEVBQUUsSUFBSTtRQUNoQixPQUFPLEVBQUU7WUFDUCxJQUFJLEVBQUUsaUJBQWlCO1lBQ3ZCLFFBQVEsRUFBRTtnQkFDUixVQUFVO2dCQUNWLFFBQVE7Z0JBQ1IsU0FBUztnQkFDVCxTQUFTO2dCQUNULFVBQVU7Z0JBQ1YsV0FBVztnQkFDWCxhQUFhO2dCQUNiLGFBQWE7Z0JBQ2IsZUFBZTtnQkFDZixZQUFZO2dCQUNaLGFBQWE7Z0JBQ2IsWUFBWTtnQkFDWixrQkFBa0I7Z0JBQ2xCLHNCQUFzQjthQUN2QjtZQUNELFNBQVMsRUFBRTtnQkFDVCxjQUFjO2dCQUNkLFFBQVE7YUFDVDtZQUNELFFBQVEsRUFBRSxJQUFJO1NBQ2Y7UUFDRCxRQUFRLEVBQUU7WUFDUixXQUFXLEVBQUU7Z0JBQ1gsNkJBQTZCO2dCQUM3Qiw0RUFBNEU7Z0JBQzVFLDBHQUEwRzthQUMzRztZQUNELG1CQUFtQixFQUFFO2dCQUNuQixrRkFBa0Y7Z0JBQ2xGLDRDQUE0QztnQkFDNUMsOEZBQThGO2FBQy9GO1NBQ0Y7S0FDRjtDQUNGLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieWFtYWhhLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL3lhbWFoYS95YW1haGEudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLFFBQVEsQ0FBQztBQUNyQyxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRywwQkFBMEIsQ0FBQztBQXlFNUQsOEZBQThGO0FBQzlGLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBbUM7SUFDM0QsTUFBTSxFQUFFLFlBQVksRUFBRSxXQUFXLEVBQUUscUJBQXFCLEVBQUUsWUFBWSxFQUFFLFFBQVEsRUFBRSxLQUFLLEVBQUUsNEJBQTRCO0lBQ3JILFdBQVcsRUFBRSxxQkFBcUIsRUFBRSxlQUFlLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxtQkFBbUI7SUFDM0YsU0FBUyxFQUFFLENBQUMsY0FBYyxFQUFFLFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFBRSxFQUFFLEVBQUUsZUFBZSxFQUFFLEVBQUU7SUFDOUUsZ0JBQWdCLEVBQUUsRUFBRSxFQUFFLGlCQUFpQixFQUFFLEVBQUUsRUFBRSxRQUFRLEVBQUUsRUFBRSxNQUFNLEVBQUUsdUJBQXVCLEVBQUUsV0FBVyxFQUFFLEtBQUssRUFBRTtDQUMvRyxDQUFDIn0=

package/dist_ts/integrations/yamaha/yamaha.validation.d.ts

@@ -0,0 +1,12 @@
+import { NoSqlConfigStore } from '../../core/classes.configstore.js';
+import type { IYamahaConfig, TYamahaControl, TYamahaModel } from './yamaha.types.js';
+export declare function yamahaRecord(value: unknown, allowed?: readonly string[]): Record<string, unknown>;
+export declare function yamahaText(value: unknown, label: string, maximum?: number): string;
+export declare function yamahaOrigin(value: unknown): string;
+export declare function yamahaDeviceId(value: unknown): string;
+export declare function yamahaModel(value: unknown): TYamahaModel;
+export declare function yamahaInteger(value: unknown, fallback?: number, minimum?: number, maximum?: number): number;
+export declare function normalizeYamahaConfig(value: unknown): Readonly<Required<Omit<IYamahaConfig, 'name'>> & Pick<IYamahaConfig, 'name'>>;
+/** The authorized host owns the optional store and its immutable home/domain declaration. */
+export declare function assertYamahaScope(store: NoSqlConfigStore | undefined, homeId: string): void;
+export declare function validateYamahaControl(value: unknown): TYamahaControl;

package/dist_ts/integrations/yamaha/yamaha.validation.js

@@ -0,0 +1,89 @@
+import * as plugins from '../../plugins.js';
+import { NoSqlConfigStore } from '../../core/classes.configstore.js';
+export function yamahaRecord(value, allowed) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) {
+        throw new TypeError('Yamaha input must be a plain data object.');
+    }
+    const result = {};
+    for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (typeof key !== 'string' || (allowed && !allowed.includes(key)) || !descriptor || !('value' in descriptor) || !descriptor.enumerable) {
+            throw new TypeError('Yamaha input contains an unsupported field or accessor.');
+        }
+        Object.defineProperty(result, key, { value: descriptor.value, enumerable: true });
+    }
+    return result;
+}
+export function yamahaText(value, label, maximum = 256) {
+    if (typeof value !== 'string' || !value || value.length > maximum || value !== value.trim() || /[\p{Cc}\p{Cs}]/u.test(value)) {
+        throw new TypeError(`Yamaha ${label} must be bounded text without control characters.`);
+    }
+    return value;
+}
+export function yamahaOrigin(value) {
+    const text = yamahaText(value, 'selected origin', 256);
+    const match = /^http:\/\/([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)(?::([0-9]+))?\/?$/.exec(text);
+    if (!match || plugins.net.isIP(match[1]) !== 4)
+        throw new TypeError('Yamaha requires a canonical literal private IPv4 HTTP origin.');
+    const octets = match[1].split('.').map(Number);
+    const [first, second] = octets;
+    if (!(first === 10 || first === 127 || (first === 172 && second >= 16 && second <= 31) ||
+        (first === 192 && second === 168) || (first === 169 && second === 254))) {
+        throw new TypeError('Yamaha requires a selected private, link-local or loopback IPv4 host.');
+    }
+    if (match[2] !== undefined && (!/^[1-9][0-9]{0,4}$/.test(match[2]) || Number(match[2]) > 65535)) {
+        throw new TypeError('Yamaha HTTP origin port is invalid.');
+    }
+    return new URL(text).origin;
+}
+export function yamahaDeviceId(value) {
+    if (typeof value !== 'string' || !/^[\x21-\x7e]{12}$/.test(value))
+        throw new TypeError('Yamaha requires the exact 12-character device_id.');
+    return value;
+}
+export function yamahaModel(value) {
+    if (value !== 'RX-V485')
+        throw new TypeError('Yamaha model has no selected native profile.');
+    return value;
+}
+export function yamahaInteger(value, fallback, minimum = Number.MIN_SAFE_INTEGER, maximum = Number.MAX_SAFE_INTEGER) {
+    const result = value === undefined ? fallback : value;
+    if (typeof result !== 'number' || !Number.isSafeInteger(result) || result < minimum || result > maximum)
+        throw new RangeError('Yamaha integer bound is invalid.');
+    return result;
+}
+export function normalizeYamahaConfig(value) {
+    const config = yamahaRecord(value, ['homeId', 'origin', 'expectedDeviceId', 'model', 'allowUnencryptedHttp', 'maxVolume', 'name', 'timeoutMs', 'maxResponseBytes', 'maxPendingOperations']);
+    if (config.allowUnencryptedHttp !== true)
+        throw new TypeError('Yamaha plaintext LAN trust must be acknowledged explicitly.');
+    return Object.freeze({
+        homeId: yamahaText(config.homeId, 'home ID'), origin: yamahaOrigin(config.origin), expectedDeviceId: yamahaDeviceId(config.expectedDeviceId),
+        model: yamahaModel(config.model), allowUnencryptedHttp: true, maxVolume: yamahaInteger(config.maxVolume),
+        ...(config.name === undefined ? {} : { name: yamahaText(config.name, 'display name', 128) }),
+        timeoutMs: yamahaInteger(config.timeoutMs, 5000, 1, 60000), maxResponseBytes: yamahaInteger(config.maxResponseBytes, 65536, 256, 1048576),
+        maxPendingOperations: yamahaInteger(config.maxPendingOperations, 16, 1, 128),
+    });
+}
+/** The authorized host owns the optional store and its immutable home/domain declaration. */
+export function assertYamahaScope(store, homeId) {
+    if (store === undefined)
+        return;
+    if (!(store instanceof NoSqlConfigStore))
+        throw new TypeError('Yamaha config store must be an actual NoSqlConfigStore.');
+    const scope = NoSqlConfigStore.prototype.getScope.call(store);
+    if (scope.homeId !== homeId || scope.integrationDomain !== 'yamaha')
+        throw new Error('Yamaha config store must match the exact home and integration.');
+}
+export function validateYamahaControl(value) {
+    const control = yamahaRecord(value, ['feature', 'value']);
+    if (control.feature === 'power' && typeof control.value === 'boolean')
+        return { feature: 'power', value: control.value };
+    if (control.feature === 'muted' && typeof control.value === 'boolean')
+        return { feature: 'muted', value: control.value };
+    if (control.feature === 'volume_raw')
+        return { feature: 'volume_raw', value: yamahaInteger(control.value) };
+    if (control.feature === 'input' && typeof control.value === 'string' && /^[a-z][a-z0-9_]{0,63}$/.test(control.value))
+        return { feature: 'input', value: control.value };
+    throw new TypeError('Yamaha supports explicit power, mute, raw integer volume and current advertised input controls.');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/zigbee2mqtt/zigbee2mqtt.classes.configflow.d.ts

@@ -1,5 +1,10 @@
 import type { IConfigFlow, IConfigFlowContext, IConfigFlowStep, IDiscoveryCandidate } from '../../core/types.js';
 import type { IZigbee2MqttConfig } from './zigbee2mqtt.types.js';
+import { NativeIntegrationOwner } from '../../core/classes.nativeintegrationowner.js';
 export declare class Zigbee2MqttConfigFlow implements IConfigFlow<IZigbee2MqttConfig> {
-    start(_candidateArg: IDiscoveryCandidate, _contextArg: IConfigFlowContext): Promise<IConfigFlowStep<IZigbee2MqttConfig>>;
+    #private;
+    constructor(ownerArg?: NativeIntegrationOwner);
+    start(_candidateArg: IDiscoveryCandidate, contextArg: IConfigFlowContext): Promise<IConfigFlowStep<IZigbee2MqttConfig>>;
+    destroy(): Promise<void>;
+    retryCleanup(): Promise<void>;
 }

package/dist_ts/integrations/zigbee2mqtt/zigbee2mqtt.classes.configflow.js

@@ -1,6 +1,10 @@
-import { zigbee2MqttConfig } from './zigbee2mqtt.validation.js';
+import { zigbee2MqttConfig, zigbee2MqttRecord } from './zigbee2mqtt.validation.js';
+import { NativeIntegrationOwner } from '../../core/classes.nativeintegrationowner.js';
 export class Zigbee2MqttConfigFlow {
-    async start(_candidateArg, _contextArg) {
+    #scope;
+    constructor(ownerArg = new NativeIntegrationOwner('zigbee2mqtt')) { this.#scope = ownerArg.createFlowScope(); }
+    async start(_candidateArg, contextArg) {
+        const context = this.#scope.admit(contextArg);
         return {
             kind: 'form', title: 'Connect Zigbee2MQTT',
             description: 'Enter the broker and exact Zigbee2MQTT base topic. Enable device availability in Zigbee2MQTT before operating devices.',
@@ -9,19 +13,25 @@ export class Zigbee2MqttConfigFlow {
                 { name: 'baseTopic', label: 'Zigbee2MQTT base topic', type: 'text', required: true },
                 { name: 'port', label: 'Broker port', type: 'number' },
                 { name: 'protocol', label: 'Protocol', type: 'select', options: [{ label: 'MQTT', value: 'mqtt' }, { label: 'MQTTS', value: 'mqtts' }] },
-                { name: 'username', label: 'Username', type: 'text' },
-                { name: 'password', label: 'Password', type: 'password' },
+                { name: 'authentication', label: 'Credential source', type: 'select', required: true, options: [{ label: 'Anonymous', value: 'anonymous' }, { label: 'Caller provider', value: 'provider' }, { label: 'Encrypted config store', value: 'config-store' }] },
+                { name: 'credentialKey', label: 'Existing credential reference', type: 'text' },
+                { name: 'allowUnencryptedLan', label: 'Allow plaintext LAN MQTT', type: 'boolean' },
             ],
-            submit: async (valuesArg) => {
+            submit: (valuesArg) => this.#scope.run(context, undefined, async () => {
                 try {
-                    const config = zigbee2MqttConfig(valuesArg);
+                    const values = zigbee2MqttRecord(valuesArg);
+                    if (!values || values.homeId !== undefined && values.homeId !== context.homeId)
+                        throw new Error('Conflicting home or invalid form data.');
+                    const config = zigbee2MqttConfig({ ...values, homeId: context.homeId });
                     return { kind: 'done', title: 'Zigbee2MQTT configured', config };
                 }
                 catch {
                     return { kind: 'error', error: 'Enter a valid broker, base topic and supported explicit configuration fields.' };
                 }
-            },
+            }),
         };
     }
+    destroy() { return this.#scope.close(); }
+    retryCleanup() { return this.#scope.retryCleanup(); }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiemlnYmVlMm1xdHQuY2xhc3Nlcy5jb25maWdmbG93LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL3ppZ2JlZTJtcXR0L3ppZ2JlZTJtcXR0LmNsYXNzZXMuY29uZmlnZmxvdy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUVoRSxNQUFNLE9BQU8scUJBQXFCO0lBQ3pCLEtBQUssQ0FBQyxLQUFLLENBQUMsYUFBa0MsRUFBRSxXQUErQjtRQUNwRixPQUFPO1lBQ0wsSUFBSSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUscUJBQXFCO1lBQzFDLFdBQVcsRUFBRSx3SEFBd0g7WUFDckksTUFBTSxFQUFFO2dCQUNOLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsYUFBYSxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRTtnQkFDcEUsRUFBRSxJQUFJLEVBQUUsV0FBVyxFQUFFLEtBQUssRUFBRSx3QkFBd0IsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUU7Z0JBQ3BGLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsYUFBYSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUU7Z0JBQ3RELEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxLQUFLLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsT0FBTyxFQUFFLENBQUMsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsRUFBRSxFQUFFLEtBQUssRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxDQUFDLEVBQUU7Z0JBQ3hJLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxLQUFLLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUU7Z0JBQ3JELEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxLQUFLLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUU7YUFDMUQ7WUFDRCxNQUFNLEVBQUUsS0FBSyxFQUFFLFNBQVMsRUFBRSxFQUFFO2dCQUMxQixJQUFJLENBQUM7b0JBQ0gsTUFBTSxNQUFNLEdBQUcsaUJBQWlCLENBQUMsU0FBMEMsQ0FBQyxDQUFDO29CQUM3RSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxFQUFFLENBQUM7Z0JBQ25FLENBQUM7Z0JBQUMsTUFBTSxDQUFDO29CQUFDLE9BQU8sRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSwrRUFBK0UsRUFBRSxDQUFDO2dCQUFDLENBQUM7WUFDL0gsQ0FBQztTQUNGLENBQUM7SUFDSixDQUFDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/zigbee2mqtt/zigbee2mqtt.classes.integration.d.ts

@@ -2,8 +2,9 @@ import { BaseIntegration } from '../../core/classes.baseintegration.js';
 import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
 import type { IIntegrationRuntime, IIntegrationSetupContext } from '../../core/types.js';
 import { Zigbee2MqttConfigFlow } from './zigbee2mqtt.classes.configflow.js';
-import type { IZigbee2MqttConfig } from './zigbee2mqtt.types.js';
+import type { IZigbee2MqttConfig, IZigbee2MqttIntegrationOptions } from './zigbee2mqtt.types.js';
 export declare class Zigbee2MqttIntegration extends BaseIntegration<IZigbee2MqttConfig> {
+    #private;
     readonly domain = "zigbee2mqtt";
     readonly displayName = "Zigbee2MQTT";
     readonly status: 'control-runtime';
@@ -14,6 +15,8 @@ export declare class Zigbee2MqttIntegration extends BaseIntegration<IZigbee2Mqtt
         upstreamPath: string;
         iotClass: string;
     };
+    constructor(optionsArg?: IZigbee2MqttIntegrationOptions);
     setup(configArg: IZigbee2MqttConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime>;
     destroy(): Promise<void>;
+    retryCleanup(): Promise<void>;
 }

package/dist_ts/integrations/zigbee2mqtt/zigbee2mqtt.classes.integration.js

@@ -1,19 +1,67 @@
 import { BaseIntegration } from '../../core/classes.baseintegration.js';
 import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import { NativeIntegrationOwner } from '../../core/classes.nativeintegrationowner.js';
 import { Zigbee2MqttConfigFlow } from './zigbee2mqtt.classes.configflow.js';
 import { Zigbee2MqttRuntime } from './zigbee2mqtt.classes.runtime.js';
+import { MqttSession } from '../mqtt/mqtt.classes.session.js';
+import { zigbee2MqttConfig, zigbee2MqttCredentials, zigbee2MqttOptions, zigbee2MqttRecord } from './zigbee2mqtt.validation.js';
 export class Zigbee2MqttIntegration extends BaseIntegration {
     domain = 'zigbee2mqtt';
     displayName = 'Zigbee2MQTT';
     status = 'control-runtime';
     discoveryDescriptor = new DiscoveryDescriptor({ integrationDomain: this.domain, displayName: this.displayName });
-    configFlow = new Zigbee2MqttConfigFlow();
+    configFlow;
+    #owner;
+    #options;
+    #controls;
     metadata = { source: 'zigbee2mqtt', upstreamPath: 'Koenkk/zigbee2mqtt', iotClass: 'local_push' };
+    constructor(optionsArg = {}) {
+        super();
+        const { options, controls } = zigbee2MqttOptions(optionsArg);
+        this.#options = options;
+        this.#controls = controls;
+        this.#owner = new NativeIntegrationOwner(this.domain, { homeId: options.homeId, capacity: options.capacity });
+        this.configFlow = new Zigbee2MqttConfigFlow(this.#owner);
+    }
     async setup(configArg, contextArg) {
-        const runtime = new Zigbee2MqttRuntime(configArg);
-        await runtime.start(contextArg.abortSignal);
-        return runtime;
+        const config = zigbee2MqttConfig(configArg);
+        return this.#owner.runSetup(contextArg, config.homeId, async (lease) => {
+            let resolver;
+            if (config.authentication === 'provider') {
+                const provider = this.#options.resolveCredentials;
+                if (!provider)
+                    throw new Error('Zigbee2MQTT provider mode requires an explicit caller resolver.');
+                resolver = async (request) => zigbee2MqttCredentials(config, await provider(Object.freeze({ ...request, host: config.host, port: config.port, protocol: config.protocol, baseTopic: config.baseTopic })));
+            }
+            else if (config.authentication === 'config-store') {
+                const store = lease.context.configStore;
+                if (!store)
+                    throw new Error('Zigbee2MQTT config-store mode requires an admitted encrypted NoSqlConfigStore.');
+                resolver = async (request) => {
+                    const value = zigbee2MqttRecord(await store.get(request.credentialKey));
+                    if (!value || Object.keys(value).some((key) => !['version', 'host', 'port', 'protocol', 'baseTopic', 'credentials'].includes(key)) ||
+                        value.version !== 1 || value.host !== config.host || value.port !== config.port || value.protocol !== config.protocol || value.baseTopic !== config.baseTopic) {
+                        throw new Error('Zigbee2MQTT encrypted credentials do not match the selected broker and base topic.');
+                    }
+                    return zigbee2MqttCredentials(config, value.credentials);
+                };
+            }
+            const session = new MqttSession({ ...config, discovery: false, birthMessage: false, willMessage: false, clean: true,
+                subscriptions: [config.baseTopic + '/#'], maxMessageTopics: (config.maxDevices ?? 2048) * 4 + 16 }, lease, resolver);
+            let runtime;
+            let attempts = 0;
+            const closeSession = () => attempts++ === 0 ? session.close() : session.retryCleanup();
+            lease.own(() => runtime ? runtime.cleanup() : closeSession());
+            const client = await session.start();
+            lease.assertOpen();
+            runtime = new Zigbee2MqttRuntime(config, client, lease, closeSession, this.#controls);
+            await runtime.start();
+            lease.assertOpen();
+            lease.promoteToRuntime();
+            return runtime;
+        });
     }
-    async destroy() { }
+    destroy() { return this.#owner.close(); }
+    retryCleanup() { return this.#owner.retryCleanup(); }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiemlnYmVlMm1xdHQuY2xhc3Nlcy5pbnRlZ3JhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy96aWdiZWUybXF0dC96aWdiZWUybXF0dC5jbGFzc2VzLmludGVncmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQUN4RSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUVoRixPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUM1RSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUd0RSxNQUFNLE9BQU8sc0JBQXVCLFNBQVEsZUFBbUM7SUFDN0QsTUFBTSxHQUFHLGFBQWEsQ0FBQztJQUN2QixXQUFXLEdBQUcsYUFBYSxDQUFDO0lBQzVCLE1BQU0sR0FBRyxpQkFBMEIsQ0FBQztJQUNwQyxtQkFBbUIsR0FBRyxJQUFJLG1CQUFtQixDQUFDLEVBQUUsaUJBQWlCLEVBQUUsSUFBSSxDQUFDLE1BQU0sRUFBRSxXQUFXLEVBQUUsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQUM7SUFDakgsVUFBVSxHQUFHLElBQUkscUJBQXFCLEVBQUUsQ0FBQztJQUN6QyxRQUFRLEdBQUcsRUFBRSxNQUFNLEVBQUUsYUFBYSxFQUFFLFlBQVksRUFBRSxvQkFBb0IsRUFBRSxRQUFRLEVBQUUsWUFBWSxFQUFFLENBQUM7SUFFMUcsS0FBSyxDQUFDLEtBQUssQ0FBQyxTQUE2QixFQUFFLFVBQW9DO1FBQ3BGLE1BQU0sT0FBTyxHQUFHLElBQUksa0JBQWtCLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDbEQsTUFBTSxPQUFPLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUM1QyxPQUFPLE9BQU8sQ0FBQztJQUNqQixDQUFDO0lBRU0sS0FBSyxDQUFDLE9BQU8sS0FBbUIsQ0FBQztDQUN6QyJ9
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/zigbee2mqtt/zigbee2mqtt.classes.runtime.d.ts

@@ -1,10 +1,15 @@
 import type * as plugins from '../../plugins.js';
 import type { IDeviceFeatureWriteRequest, IIntegrationEntity, IIntegrationEvent, IIntegrationRuntime, IServiceCallRequest, IServiceCallResult } from '../../core/types.js';
+import type { MqttClient } from '../mqtt/mqtt.classes.client.js';
 import type { IZigbee2MqttConfig } from './zigbee2mqtt.types.js';
+import type { INativeSetupLease } from '../../core/classes.nativeintegrationowner.js';
 export declare class Zigbee2MqttRuntime implements IIntegrationRuntime {
+    #private;
+    private readonly client;
+    private readonly lease;
+    private readonly closeSession;
     readonly domain = "zigbee2mqtt";
     private readonly config;
-    private readonly client;
     private readonly removeMessageHandler;
     private readonly removeConnectionHandler;
     private readonly handlers;
@@ -24,11 +29,12 @@ export declare class Zigbee2MqttRuntime implements IIntegrationRuntime {
     private inventoryCurrent;
     private inventoryError?;
     private destroyed;
-    private destroyPromise?;
     private activeWrites;
-    private removeSetupAbort?;
-    constructor(configArg: IZigbee2MqttConfig);
-    start(abortSignalArg?: AbortSignal): Promise<void>;
+    private readonly pendingHandlers;
+    private readonly callbackFailures;
+    private readonly ownerAbort;
+    constructor(configArg: IZigbee2MqttConfig, client: MqttClient, lease: INativeSetupLease, closeSession: () => Promise<void>, controlsArg: ReadonlySet<string>);
+    start(): Promise<void>;
     isHealthy(): boolean;
     devices(abortSignalArg?: AbortSignal): Promise<plugins.shxInterfaces.data.IDeviceDefinition[]>;
     entities(): Promise<IIntegrationEntity[]>;
@@ -47,7 +53,7 @@ export declare class Zigbee2MqttRuntime implements IIntegrationRuntime {
     private deviceForTopic;
     private waitForInventory;
     private resolveReady;
-    private destroyConnection;
+    cleanup(): Promise<void>;
     private assertOpen;
     private emit;
     private emitError;