@smarthome.exchange/integrations 1.0.0 → 2.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smarthome.exchange/integrations",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "private": false,
   "description": "TypeScript-native device integrations for smarthome.exchange.",
   "engines": {
@@ -19,9 +19,9 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "dependencies": {
-    "@ecobridge.xyz/devicemanager": "4.3.0",
+    "@ecobridge.xyz/devicemanager": "4.8.0",
     "@lossless.org/client": "1.19.0",
-    "@smarthome.exchange/interfaces": "2.0.0",
+    "@smarthome.exchange/interfaces": "2.1.0",
     "home-assistant-js-websocket": "^9.6.0",
     "mqtt": "5.16.0",
     "esphome-client": "2.0.0",