@smarthome.exchange/integrations 0.2.0 → 2.0.0

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

@@ -1,15 +1,250 @@
-import { SimpleLocalIntegration } from '../../core/index.js';
+import * as plugins from '../../plugins.js';
+import { BaseIntegration } from '../../core/classes.baseintegration.js';
+import { NativeIntegrationOwner } from '../../core/classes.nativeintegrationowner.js';
+import { YamahaClient } from './yamaha.classes.client.js';
 import { YamahaConfigFlow } from './yamaha.classes.configflow.js';
 import { createYamahaDiscoveryDescriptor } from './yamaha.discovery.js';
-import { yamahaDomain, yamahaProfile } from './yamaha.types.js';
-export class YamahaIntegration extends SimpleLocalIntegration {
-    domain = yamahaDomain;
+import { YamahaMapper } from './yamaha.mapper.js';
+import { normalizeYamahaConfig, yamahaRecord, yamahaText, validateYamahaControl } from './yamaha.validation.js';
+export class YamahaIntegration extends BaseIntegration {
+    domain = 'yamaha';
+    displayName = 'Yamaha RX-V485 main zone';
+    status = 'control-runtime';
     discoveryDescriptor = createYamahaDiscoveryDescriptor();
-    configFlow = new YamahaConfigFlow();
-    constructor() {
-        super(yamahaProfile);
+    configFlow;
+    metadata = { source: 'native-typescript', integrationType: 'device', iotClass: 'local_poll', selectedModel: 'RX-V485', zone: 'main' };
+    owner;
+    closePromise;
+    constructor(options = {}) {
+        super();
+        const values = yamahaRecord(options, ['homeId']);
+        this.owner = new NativeIntegrationOwner(this.domain, values.homeId === undefined ? {} : { homeId: yamahaText(values.homeId, 'constructor home ID') });
+        this.configFlow = new YamahaConfigFlow(this.owner.createFlowScope());
     }
+    setup(config, context) {
+        try {
+            const normalized = normalizeYamahaConfig(config);
+            return this.owner.runSetup(context, normalized.homeId, async (lease) => {
+                const client = new YamahaClient(normalized, lease.context);
+                let runtime;
+                let cleanupStarted = false;
+                lease.own(() => {
+                    const retry = cleanupStarted;
+                    cleanupStarted = true;
+                    return runtime ? runtime.closeOwnedResources(retry) : retry ? client.retryCleanup() : client.destroy();
+                });
+                const initial = await client.start(lease.signal);
+                lease.assertOpen();
+                runtime = new YamahaRuntime(client, initial, lease);
+                lease.promoteToRuntime();
+                return runtime;
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    destroy() {
+        if (!this.closePromise) {
+            let closing = [];
+            this.closePromise = Promise.resolve().then(async () => {
+                const results = await Promise.allSettled(closing);
+                const failures = results.filter((entry) => entry.status === 'rejected');
+                if (failures.length)
+                    throw new AggregateError(failures.map((entry) => entry.reason), 'Yamaha owned cleanup failed.');
+            });
+            closing = [this.configFlow.destroy(), this.owner.close()];
+        }
+        return this.closePromise;
+    }
+    retryCleanup() { return this.owner.retryCleanup(); }
 }
 export class HomeAssistantYamahaIntegration extends YamahaIntegration {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieWFtYWhhLmNsYXNzZXMuaW50ZWdyYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMveWFtYWhhL3lhbWFoYS5jbGFzc2VzLmludGVncmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQzdELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ2xFLE9BQU8sRUFBRSwrQkFBK0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXhFLE9BQU8sRUFBRSxZQUFZLEVBQUUsYUFBYSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFaEUsTUFBTSxPQUFPLGlCQUFrQixTQUFRLHNCQUFxQztJQUMxRCxNQUFNLEdBQUcsWUFBWSxDQUFDO0lBQ3RCLG1CQUFtQixHQUFHLCtCQUErQixFQUFFLENBQUM7SUFDeEQsVUFBVSxHQUFHLElBQUksZ0JBQWdCLEVBQUUsQ0FBQztJQUVwRDtRQUNFLEtBQUssQ0FBQyxhQUFhLENBQUMsQ0FBQztJQUN2QixDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sOEJBQStCLFNBQVEsaUJBQWlCO0NBQUcifQ==
+class YamahaRuntime {
+    client;
+    snapshot;
+    lease;
+    domain = 'yamaha';
+    subscriptions = new Set();
+    closePromise;
+    closed = false;
+    constructor(client, snapshot, lease) {
+        this.client = client;
+        this.snapshot = snapshot;
+        this.lease = lease;
+    }
+    isHealthy() { return !this.closed && !this.lease.signal.aborted && this.client.isHealthy(); }
+    async devices(signal) {
+        this.assertOpen();
+        const snapshot = await this.client.getSnapshot(signal);
+        this.publish(snapshot);
+        return YamahaMapper.toDevices(snapshot);
+    }
+    async entities() {
+        this.assertOpen();
+        const snapshot = await this.client.getSnapshot();
+        this.publish(snapshot);
+        return YamahaMapper.toEntities(snapshot);
+    }
+    async writeFeature(input, signal) {
+        this.assertOpen();
+        const request = yamahaRecord(input, ['device', 'feature', 'value']);
+        const device = yamahaRecord(request.device);
+        const feature = yamahaRecord(request.feature);
+        const canonical = YamahaMapper.toDevices(this.snapshot)[0];
+        if (device.id !== canonical.id || device.integrationDomain !== this.domain)
+            throw new Error('Yamaha feature target is outside the selected home and receiver.');
+        const admitted = canonical.features.find((entry) => entry.id === feature.id);
+        if (!admitted?.writable || feature.capability !== admitted.capability)
+            throw new Error('Yamaha feature is not writable for the selected receiver.');
+        return this.control(validateYamahaControl({ feature: admitted.id, value: request.value }), signal);
+    }
+    async callService(input) {
+        this.assertOpen();
+        const request = yamahaRecord(input, ['domain', 'service', 'target', 'data']);
+        const target = yamahaRecord(request.target, ['deviceId', 'entityId']);
+        const deviceId = YamahaMapper.deviceId(this.snapshot.homeId, this.snapshot.identity.deviceId);
+        const entityId = YamahaMapper.entityId(this.snapshot.homeId, this.snapshot.identity.deviceId);
+        if ((!target.deviceId && !target.entityId) || (target.deviceId !== undefined && target.deviceId !== deviceId) ||
+            (target.entityId !== undefined && target.entityId !== entityId))
+            throw new Error('Yamaha service target is outside the selected home and receiver.');
+        if (request.domain !== 'media_player')
+            throw new Error('Yamaha services use media_player.');
+        let control;
+        if (request.service === 'turn_on' || request.service === 'turn_off') {
+            yamahaRecord(request.data ?? {}, []);
+            control = { feature: 'power', value: request.service === 'turn_on' };
+        }
+        else if (request.service === 'volume_set') {
+            const data = yamahaRecord(request.data, ['volume_raw']);
+            control = validateYamahaControl({ feature: 'volume_raw', value: data.volume_raw });
+        }
+        else if (request.service === 'volume_mute') {
+            const data = yamahaRecord(request.data, ['is_volume_muted']);
+            control = validateYamahaControl({ feature: 'muted', value: data.is_volume_muted });
+        }
+        else if (request.service === 'select_source') {
+            const data = yamahaRecord(request.data, ['source']);
+            control = validateYamahaControl({ feature: 'input', value: data.source });
+        }
+        else
+            throw new Error('Yamaha supports explicit power, mute, absolute raw volume and freshly advertised inputs only.');
+        return this.control(control);
+    }
+    /** Observe calls publish completed snapshots; subscriptions never create a hidden polling loop. */
+    async subscribe(handler, signal) {
+        this.assertOpen();
+        if (typeof handler !== 'function' || (signal !== undefined && !(signal instanceof AbortSignal)))
+            throw new TypeError('Yamaha subscription requires a callback and optional AbortSignal.');
+        signal?.throwIfAborted();
+        if (this.subscriptions.size >= 32)
+            throw new Error('Yamaha subscription capacity reached.');
+        const subscription = {
+            handler, active: true, failed: false, callbacks: new Set(),
+            detach: () => { subscription.active = false; signal?.removeEventListener('abort', aborted); },
+            stop: () => {
+                if (!subscription.stopPromise) {
+                    subscription.stopPromise = Promise.resolve().then(async () => {
+                        const results = await Promise.allSettled([...subscription.callbacks]);
+                        this.subscriptions.delete(subscription);
+                        const failures = results.filter((entry) => entry.status === 'rejected').map((entry) => entry.reason);
+                        if (subscription.failed)
+                            failures.push(subscription.failure);
+                        const errors = [...new Set(failures)];
+                        if (errors.length === 1)
+                            throw errors[0];
+                        if (errors.length)
+                            throw new AggregateError(errors, 'Yamaha subscriber cleanup failed.');
+                    });
+                    subscription.detach();
+                }
+                return subscription.stopPromise;
+            },
+        };
+        const aborted = () => {
+            subscription.detach();
+            if (!subscription.callbacks.size && !subscription.failed)
+                this.subscriptions.delete(subscription);
+        };
+        signal?.addEventListener('abort', aborted, { once: true });
+        this.subscriptions.add(subscription);
+        if (signal?.aborted)
+            aborted();
+        return subscription.stop;
+    }
+    destroy() { return this.lease.close(); }
+    /** Called only by the retained lease, including its explicit cleanup retry. */
+    closeOwnedResources(retry = false) {
+        if (retry)
+            return this.drainOwnedResources(true);
+        if (!this.closePromise) {
+            this.closed = true;
+            this.closePromise = Promise.resolve().then(() => this.drainOwnedResources(false));
+            for (const subscription of this.subscriptions)
+                subscription.detach();
+        }
+        return this.closePromise;
+    }
+    async drainOwnedResources(retry) {
+        const results = await Promise.allSettled([
+            Promise.resolve().then(() => retry ? this.client.retryCleanup() : this.client.destroy()),
+            ...[...this.subscriptions].map((entry) => Promise.resolve().then(() => entry.stop())),
+        ]);
+        const failures = results.filter((entry) => entry.status === 'rejected');
+        if (failures.length)
+            throw new AggregateError(failures.map((entry) => entry.reason), 'Yamaha owned cleanup or subscriber failed.');
+    }
+    async control(control, signal) {
+        try {
+            const result = await this.client.setControl(control, signal);
+            this.publish(result.snapshot);
+            return this.result(result);
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Yamaha control failed.',
+                data: { effectOutcome: error instanceof plugins.ecobridgeDeviceManager.YamahaProtocolError ? error.effectOutcome : 'not-sent' } };
+        }
+    }
+    result(result) {
+        return { success: result.outcome === 'observed-target', ...(result.outcome === 'indeterminate' ? { error: 'Requested receiver setting was not observed.' } : {}),
+            data: { dispatch: result.dispatch, outcome: result.outcome, devices: YamahaMapper.toDevices(result.snapshot), entities: YamahaMapper.toEntities(result.snapshot) } };
+    }
+    publish(snapshot) {
+        if (this.closed)
+            return;
+        this.snapshot = snapshot;
+        for (const subscription of [...this.subscriptions]) {
+            if (this.closed)
+                break;
+            if (!subscription.active)
+                continue;
+            if (subscription.callbacks.size) {
+                subscription.failed = true;
+                subscription.failure = new Error('Yamaha subscriber must drain its previous observation before another notification.');
+                subscription.detach();
+                continue;
+            }
+            const event = { type: 'state_changed', integrationDomain: this.domain,
+                deviceId: YamahaMapper.deviceId(snapshot.homeId, snapshot.identity.deviceId), entityId: YamahaMapper.entityId(snapshot.homeId, snapshot.identity.deviceId),
+                data: structuredClone(snapshot), timestamp: Date.now() };
+            // Register the actual callback promise before user code can synchronously close the runtime.
+            const pending = Promise.resolve().then(() => subscription.handler(event)).then(() => { }, (error) => {
+                subscription.failed = true;
+                subscription.failure = error;
+                subscription.detach();
+                throw error;
+            });
+            subscription.callbacks.add(pending);
+            const settled = () => {
+                subscription.callbacks.delete(pending);
+                if (!subscription.active && !subscription.failed)
+                    this.subscriptions.delete(subscription);
+            };
+            void pending.then(settled, settled);
+        }
+    }
+    assertOpen() { if (this.closed)
+        throw new Error('Yamaha runtime is closed.'); this.lease.assertOpen(); }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yamaha.classes.integration.js","sourceRoot":"","sources":["../../../ts/integrations/yamaha/yamaha.classes.integration.ts"],"names":[],"mappings":"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"}

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

@@ -1 +1,13 @@
-export declare const createYamahaDiscoveryDescriptor: () => import("../../core/classes.discoverydescriptor.js").DiscoveryDescriptor;
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import type { IDiscoveryCandidate, IDiscoveryMatch, IDiscoveryMatcher, IDiscoveryValidator } from '../../core/types.js';
+import type { IYamahaManualEntry } from './yamaha.types.js';
+export declare class YamahaManualMatcher implements IDiscoveryMatcher<IYamahaManualEntry> {
+    readonly id = "yamaha-manual-match";
+    readonly source: 'manual';
+    matches(input: IYamahaManualEntry): Promise<IDiscoveryMatch>;
+}
+export declare class YamahaCandidateValidator implements IDiscoveryValidator {
+    readonly id = "yamaha-candidate-validator";
+    validate(input: IDiscoveryCandidate): Promise<IDiscoveryMatch>;
+}
+export declare const createYamahaDiscoveryDescriptor: () => DiscoveryDescriptor;

package/dist_ts/integrations/yamaha/yamaha.discovery.js

@@ -1,4 +1,57 @@
-import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
-import { yamahaProfile } from './yamaha.types.js';
-export const createYamahaDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(yamahaProfile);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieWFtYWhhLmRpc2NvdmVyeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy95YW1haGEveWFtYWhhLmRpc2NvdmVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0NBQW9DLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUMzRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFbEQsTUFBTSxDQUFDLE1BQU0sK0JBQStCLEdBQUcsR0FBRyxFQUFFLENBQUMsb0NBQW9DLENBQUMsYUFBYSxDQUFDLENBQUMifQ==
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import { yamahaDeviceId, yamahaModel, yamahaOrigin, yamahaRecord, yamahaText } from './yamaha.validation.js';
+const miss = (reason) => ({ matched: false, confidence: 'low', reason });
+function hint(origin, deviceId, model, name) {
+    const selectedOrigin = yamahaOrigin(origin);
+    const identity = yamahaDeviceId(deviceId);
+    const selectedModel = yamahaModel(model);
+    const selectedName = name === undefined ? undefined : yamahaText(name, 'display name', 128);
+    const url = new URL(selectedOrigin);
+    return { matched: true, confidence: 'medium', normalizedDeviceId: identity,
+        reason: 'Selected RX-V485 setup hint; live identity, features and main-zone status must still be verified.',
+        candidate: { source: 'manual', integrationDomain: 'yamaha', id: identity, host: url.hostname,
+            port: Number(url.port || 80), manufacturer: 'Yamaha', model: selectedModel, name: selectedName,
+            metadata: { origin: selectedOrigin, identityEvidence: 'unauthenticated-manual-hint' } } };
+}
+export class YamahaManualMatcher {
+    id = 'yamaha-manual-match';
+    source = 'manual';
+    async matches(input) {
+        try {
+            const values = yamahaRecord(input, ['origin', 'expectedDeviceId', 'id', 'model', 'name', 'manufacturer', 'metadata']);
+            const metadata = values.metadata === undefined ? {} : yamahaRecord(values.metadata, ['origin']);
+            if (values.manufacturer !== undefined && values.manufacturer !== 'Yamaha')
+                return miss('Manufacturer does not match the selected Yamaha profile.');
+            if (values.expectedDeviceId !== undefined && values.id !== undefined && values.expectedDeviceId !== values.id)
+                return miss('Manual receiver identities conflict.');
+            if (values.origin !== undefined && metadata.origin !== undefined && yamahaOrigin(values.origin) !== yamahaOrigin(metadata.origin))
+                return miss('Manual selected origins conflict.');
+            return hint(values.origin ?? metadata.origin, values.expectedDeviceId ?? values.id, values.model, values.name);
+        }
+        catch {
+            return miss('Manual setup requires an exact RX-V485 identity and selected literal private HTTP origin.');
+        }
+    }
+}
+export class YamahaCandidateValidator {
+    id = 'yamaha-candidate-validator';
+    async validate(input) {
+        try {
+            const values = yamahaRecord(input, ['source', 'integrationDomain', 'id', 'host', 'port', 'name', 'manufacturer', 'model', 'metadata']);
+            if (values.source !== 'manual' || values.integrationDomain !== 'yamaha' || values.manufacturer !== 'Yamaha')
+                return miss('Candidate does not belong to selected Yamaha manual admission.');
+            const metadata = yamahaRecord(values.metadata, ['origin', 'identityEvidence']);
+            const selectedOrigin = yamahaOrigin(metadata.origin);
+            const url = new URL(selectedOrigin);
+            if (values.host !== url.hostname || values.port !== Number(url.port || 80))
+                return miss('Candidate host or port conflicts with the selected origin.');
+            return hint(selectedOrigin, values.id, values.model, values.name);
+        }
+        catch {
+            return miss('Candidate cannot satisfy selected Yamaha admission.');
+        }
+    }
+}
+export const createYamahaDiscoveryDescriptor = () => new DiscoveryDescriptor({ integrationDomain: 'yamaha', displayName: 'Yamaha RX-V485 main zone' })
+    .addMatcher(new YamahaManualMatcher()).addValidator(new YamahaCandidateValidator());
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieWFtYWhhLmRpc2NvdmVyeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy95YW1haGEveWFtYWhhLmRpc2NvdmVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUdoRixPQUFPLEVBQUUsY0FBYyxFQUFFLFdBQVcsRUFBRSxZQUFZLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRTdHLE1BQU0sSUFBSSxHQUFHLENBQUMsTUFBYyxFQUFtQixFQUFFLENBQUMsQ0FBQyxFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsQ0FBQyxDQUFDO0FBRWxHLFNBQVMsSUFBSSxDQUFDLE1BQWUsRUFBRSxRQUFpQixFQUFFLEtBQWMsRUFBRSxJQUFhO0lBQzdFLE1BQU0sY0FBYyxHQUFHLFlBQVksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUM1QyxNQUFNLFFBQVEsR0FBRyxjQUFjLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDMUMsTUFBTSxhQUFhLEdBQUcsV0FBVyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3pDLE1BQU0sWUFBWSxHQUFHLElBQUksS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLElBQUksRUFBRSxjQUFjLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDNUYsTUFBTSxHQUFHLEdBQUcsSUFBSSxHQUFHLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDcEMsT0FBTyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxrQkFBa0IsRUFBRSxRQUFRO1FBQ3hFLE1BQU0sRUFBRSxtR0FBbUc7UUFDM0csU0FBUyxFQUFFLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxpQkFBaUIsRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsR0FBRyxDQUFDLFFBQVE7WUFDMUYsSUFBSSxFQUFFLE1BQU0sQ0FBQyxHQUFHLENBQUMsSUFBSSxJQUFJLEVBQUUsQ0FBQyxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLGFBQWEsRUFBRSxJQUFJLEVBQUUsWUFBWTtZQUM5RixRQUFRLEVBQUUsRUFBRSxNQUFNLEVBQUUsY0FBYyxFQUFFLGdCQUFnQixFQUFFLDZCQUE2QixFQUFFLEVBQUUsRUFBRSxDQUFDO0FBQ2hHLENBQUM7QUFFRCxNQUFNLE9BQU8sbUJBQW1CO0lBQ2QsRUFBRSxHQUFHLHFCQUFxQixDQUFDO0lBQzNCLE1BQU0sR0FBRyxRQUFpQixDQUFDO0lBQ3BDLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBeUI7UUFDNUMsSUFBSSxDQUFDO1lBQ0gsTUFBTSxNQUFNLEdBQUcsWUFBWSxDQUFDLEtBQUssRUFBRSxDQUFDLFFBQVEsRUFBRSxrQkFBa0IsRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxjQUFjLEVBQUUsVUFBVSxDQUFDLENBQUMsQ0FBQztZQUN0SCxNQUFNLFFBQVEsR0FBRyxNQUFNLENBQUMsUUFBUSxLQUFLLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLFFBQVEsRUFBRSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7WUFDaEcsSUFBSSxNQUFNLENBQUMsWUFBWSxLQUFLLFNBQVMsSUFBSSxNQUFNLENBQUMsWUFBWSxLQUFLLFFBQVE7Z0JBQUUsT0FBTyxJQUFJLENBQUMsMERBQTBELENBQUMsQ0FBQztZQUNuSixJQUFJLE1BQU0sQ0FBQyxnQkFBZ0IsS0FBSyxTQUFTLElBQUksTUFBTSxDQUFDLEVBQUUsS0FBSyxTQUFTLElBQUksTUFBTSxDQUFDLGdCQUFnQixLQUFLLE1BQU0sQ0FBQyxFQUFFO2dCQUFFLE9BQU8sSUFBSSxDQUFDLHNDQUFzQyxDQUFDLENBQUM7WUFDbkssSUFBSSxNQUFNLENBQUMsTUFBTSxLQUFLLFNBQVMsSUFBSSxRQUFRLENBQUMsTUFBTSxLQUFLLFNBQVMsSUFBSSxZQUFZLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxLQUFLLFlBQVksQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDO2dCQUFFLE9BQU8sSUFBSSxDQUFDLG1DQUFtQyxDQUFDLENBQUM7WUFDcEwsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sSUFBSSxRQUFRLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxnQkFBZ0IsSUFBSSxNQUFNLENBQUMsRUFBRSxFQUFFLE1BQU0sQ0FBQyxLQUFLLEVBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2pILENBQUM7UUFBQyxNQUFNLENBQUM7WUFBQyxPQUFPLElBQUksQ0FBQywyRkFBMkYsQ0FBQyxDQUFDO1FBQUMsQ0FBQztJQUN2SCxDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sd0JBQXdCO0lBQ25CLEVBQUUsR0FBRyw0QkFBNEIsQ0FBQztJQUMzQyxLQUFLLENBQUMsUUFBUSxDQUFDLEtBQTBCO1FBQzlDLElBQUksQ0FBQztZQUNILE1BQU0sTUFBTSxHQUFHLFlBQVksQ0FBQyxLQUFLLEVBQUUsQ0FBQyxRQUFRLEVBQUUsbUJBQW1CLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLGNBQWMsRUFBRSxPQUFPLEVBQUUsVUFBVSxDQUFDLENBQUMsQ0FBQztZQUN2SSxJQUFJLE1BQU0sQ0FBQyxNQUFNLEtBQUssUUFBUSxJQUFJLE1BQU0sQ0FBQyxpQkFBaUIsS0FBSyxRQUFRLElBQUksTUFBTSxDQUFDLFlBQVksS0FBSyxRQUFRO2dCQUFFLE9BQU8sSUFBSSxDQUFDLGdFQUFnRSxDQUFDLENBQUM7WUFDM0wsTUFBTSxRQUFRLEdBQUcsWUFBWSxDQUFDLE1BQU0sQ0FBQyxRQUFRLEVBQUUsQ0FBQyxRQUFRLEVBQUUsa0JBQWtCLENBQUMsQ0FBQyxDQUFDO1lBQy9FLE1BQU0sY0FBYyxHQUFHLFlBQVksQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDckQsTUFBTSxHQUFHLEdBQUcsSUFBSSxHQUFHLENBQUMsY0FBYyxDQUFDLENBQUM7WUFDcEMsSUFBSSxNQUFNLENBQUMsSUFBSSxLQUFLLEdBQUcsQ0FBQyxRQUFRLElBQUksTUFBTSxDQUFDLElBQUksS0FBSyxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksSUFBSSxFQUFFLENBQUM7Z0JBQUUsT0FBTyxJQUFJLENBQUMsNERBQTRELENBQUMsQ0FBQztZQUN0SixPQUFPLElBQUksQ0FBQyxjQUFjLEVBQUUsTUFBTSxDQUFDLEVBQUUsRUFBRSxNQUFNLENBQUMsS0FBSyxFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNwRSxDQUFDO1FBQUMsTUFBTSxDQUFDO1lBQUMsT0FBTyxJQUFJLENBQUMscURBQXFELENBQUMsQ0FBQztRQUFDLENBQUM7SUFDakYsQ0FBQztDQUNGO0FBRUQsTUFBTSxDQUFDLE1BQU0sK0JBQStCLEdBQUcsR0FBd0IsRUFBRSxDQUN2RSxJQUFJLG1CQUFtQixDQUFDLEVBQUUsaUJBQWlCLEVBQUUsUUFBUSxFQUFFLFdBQVcsRUFBRSwwQkFBMEIsRUFBRSxDQUFDO0tBQzlGLFVBQVUsQ0FBQyxJQUFJLG1CQUFtQixFQUFFLENBQUMsQ0FBQyxZQUFZLENBQUMsSUFBSSx3QkFBd0IsRUFBRSxDQUFDLENBQUMifQ==

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

@@ -1,10 +1,18 @@
-import type * as shxInterfaces from '@smarthome.exchange/interfaces';
-import { type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
-import type { IYamahaConfig } from './yamaha.types.js';
+import type * as plugins from '../../plugins.js';
+import type { ISimpleLocalSnapshotOptions } from '../../core/classes.simplelocalintegration.js';
+import type { IIntegrationEntity } from '../../core/types.js';
+import type { IYamahaOfflineConfig, IYamahaOfflineSnapshot, IYamahaSnapshot, TYamahaRawData } from './yamaha.types.js';
 export declare class YamahaMapper {
-    static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IYamahaConfig>, 'profile'>): ISimpleLocalSnapshot;
-    static toSnapshotFromRaw(configArg: IYamahaConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot;
-    static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[];
-    static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[];
-    static slug(valueArg: unknown): string;
+    static deviceId(homeId: string, deviceId: string): string;
+    static entityId(homeId: string, deviceId: string): string;
+    static toDevices(snapshot: IYamahaSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[];
+    static toEntities(snapshot: IYamahaSnapshot): IIntegrationEntity[];
+}
+/** The former generic mapping remains available without admitting data as a live device. */
+export declare class YamahaOfflineMapper {
+    static toSnapshot(options: Omit<ISimpleLocalSnapshotOptions<IYamahaOfflineConfig>, 'profile'>): IYamahaOfflineSnapshot;
+    static toSnapshotFromRaw(config: IYamahaOfflineConfig, rawData: TYamahaRawData): IYamahaOfflineSnapshot;
+    static toDevices(snapshot: IYamahaOfflineSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[];
+    static toEntities(snapshot: IYamahaOfflineSnapshot): IIntegrationEntity[];
+    static slug(value: unknown): string;
 }

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;