@smarthome.exchange/integrations 1.0.0 → 3.0.0

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

@@ -1,8 +1,108 @@
-import { SimpleLocalConfigFlow } from '../../core/index.js';
-import { yamahaProfile } from './yamaha.types.js';
-export class YamahaConfigFlow extends SimpleLocalConfigFlow {
-    constructor() {
-        super(yamahaProfile);
+import * as plugins from '../../plugins.js';
+import { NativeIntegrationOwner, NativeIntegrationScope } from '../../core/classes.nativeintegrationowner.js';
+import { YamahaClient } from './yamaha.classes.client.js';
+import { normalizeYamahaConfig, yamahaRecord } from './yamaha.validation.js';
+export class YamahaConfigFlow {
+    scope;
+    writes = new Set();
+    closePromise;
+    constructor(scope = new NativeIntegrationOwner('yamaha').createFlowScope()) {
+        this.scope = scope;
     }
+    async start(input, context) {
+        const candidate = yamahaRecord(input);
+        if (candidate.integrationDomain !== 'yamaha')
+            return { kind: 'error', error: 'Candidate does not belong to Yamaha.' };
+        const metadata = candidate.metadata === undefined ? {} : yamahaRecord(candidate.metadata);
+        const hints = { origin: metadata.origin, expectedDeviceId: candidate.id, model: candidate.model };
+        const captured = this.scope.admit(context);
+        let pending = false;
+        let completed = false;
+        return {
+            kind: 'form', title: 'Connect selected Yamaha RX-V485 main zone',
+            description: 'Confirm selected literal private HTTP origin, expected device_id, plaintext LAN trust and an owner ceiling in vendor raw integer volume units. The embedding host selects the home. No percentage or dB conversion is inferred.',
+            fields: [
+                { name: 'origin', label: 'Selected receiver HTTP origin', type: 'text', required: true },
+                { name: 'expectedDeviceId', label: 'Expected 12-character device_id', type: 'text', required: true },
+                { name: 'model', label: 'Documented model', type: 'select', required: true, options: [{ label: 'RX-V485', value: 'RX-V485' }] },
+                { name: 'allowUnencryptedHttp', label: 'Allow unauthenticated plaintext LAN HTTP', type: 'boolean', required: true },
+                { name: 'maxVolume', label: 'Owner maximum volume (vendor raw integer units)', type: 'number', required: true },
+                { name: 'name', label: 'Display name', type: 'text' },
+            ],
+            submit: (inputValues) => {
+                if (pending || completed)
+                    return Promise.reject(new Error('Yamaha config flow submission is unavailable.'));
+                try {
+                    const values = yamahaRecord(inputValues, ['homeId', 'origin', 'expectedDeviceId', 'model', 'allowUnencryptedHttp', 'maxVolume', 'name', 'timeoutMs', 'maxResponseBytes', 'maxPendingOperations']);
+                    if (values.homeId !== undefined && values.homeId !== captured.homeId)
+                        throw new Error('Yamaha submitted home conflicts with the selected host home.');
+                    const config = normalizeYamahaConfig({ ...hints, ...values, homeId: captured.homeId });
+                    const submission = this.scope.run(captured, config.homeId, async (lease) => {
+                        const client = new YamahaClient(config, lease.context);
+                        let cleanupStarted = false;
+                        lease.own(() => {
+                            const retry = cleanupStarted;
+                            cleanupStarted = true;
+                            return retry ? client.retryCleanup() : client.destroy();
+                        });
+                        try {
+                            await client.start(lease.signal);
+                        }
+                        catch (error) {
+                            if (!lease.signal.aborted && error instanceof plugins.ecobridgeDeviceManager.YamahaProtocolError) {
+                                return { kind: 'error', title: 'Receiver admission failed', error: error.message };
+                            }
+                            throw error;
+                        }
+                        lease.assertOpen();
+                        const store = lease.context.configStore;
+                        if (store) {
+                            // Ownership precedes a synchronous caller callback; accepted writes drain during close.
+                            const write = { accepted: false, promise: Promise.resolve().then(async () => {
+                                    lease.assertOpen();
+                                    write.accepted = true;
+                                    await store.set(`receiver.${encodeURIComponent(config.expectedDeviceId)}`, config);
+                                }) };
+                            this.writes.add(write);
+                            try {
+                                await write.promise;
+                            }
+                            finally {
+                                this.writes.delete(write);
+                            }
+                        }
+                        completed = true;
+                        return { kind: 'done', title: 'Selected receiver admitted', config };
+                    });
+                    pending = true;
+                    const settled = () => { pending = false; };
+                    void submission.then(settled, settled);
+                    return submission;
+                }
+                catch (error) {
+                    return Promise.reject(error);
+                }
+            },
+        };
+    }
+    destroy() {
+        if (!this.closePromise) {
+            const writes = [...this.writes];
+            this.closePromise = Promise.resolve().then(async () => {
+                const [cleanup, results] = await Promise.all([
+                    Promise.allSettled([this.scope.close()]), Promise.allSettled(writes.map((write) => write.promise)),
+                ]);
+                const failures = cleanup.filter((entry) => entry.status === 'rejected').map((entry) => entry.reason);
+                results.forEach((entry, index) => { if (entry.status === 'rejected' && writes[index].accepted)
+                    failures.push(entry.reason); });
+                if (failures.length)
+                    throw new AggregateError(failures, 'Yamaha config flow cleanup failed.');
+            });
+            // Terminal admission is immediate; close owns all accepted submissions and borrowed-store writes.
+            void this.scope.close().catch(() => undefined);
+        }
+        return this.closePromise;
+    }
+    retryCleanup() { return this.scope.retryCleanup(); }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieWFtYWhhLmNsYXNzZXMuY29uZmlnZmxvdy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy95YW1haGEveWFtYWhhLmNsYXNzZXMuY29uZmlnZmxvdy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUU1RCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFbEQsTUFBTSxPQUFPLGdCQUFpQixTQUFRLHFCQUFvQztJQUN4RTtRQUNFLEtBQUssQ0FBQyxhQUFhLENBQUMsQ0FBQztJQUN2QixDQUFDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,11 +1,29 @@
-import { SimpleLocalIntegration } from '../../core/index.js';
+import { BaseIntegration } from '../../core/classes.baseintegration.js';
+import type { IIntegrationRuntime, INativeIntegrationSetupContext } from '../../core/types.js';
 import { YamahaConfigFlow } from './yamaha.classes.configflow.js';
 import type { IYamahaConfig } from './yamaha.types.js';
-export declare class YamahaIntegration extends SimpleLocalIntegration<IYamahaConfig> {
+export interface IYamahaIntegrationOptions {
+    readonly homeId?: string;
+}
+export declare class YamahaIntegration extends BaseIntegration<IYamahaConfig> {
     readonly domain = "yamaha";
-    readonly discoveryDescriptor: import("../../core/classes.discoverydescriptor.js").DiscoveryDescriptor;
+    readonly displayName = "Yamaha RX-V485 main zone";
+    readonly status: 'control-runtime';
+    readonly discoveryDescriptor: import("../../index.js").DiscoveryDescriptor;
     readonly configFlow: YamahaConfigFlow;
-    constructor();
+    readonly metadata: {
+        source: string;
+        integrationType: string;
+        iotClass: string;
+        selectedModel: string;
+        zone: string;
+    };
+    private readonly owner;
+    private closePromise?;
+    constructor(options?: IYamahaIntegrationOptions);
+    setup(config: IYamahaConfig, context: INativeIntegrationSetupContext): Promise<IIntegrationRuntime>;
+    destroy(): Promise<void>;
+    retryCleanup(): Promise<void>;
 }
 export declare class HomeAssistantYamahaIntegration extends YamahaIntegration {
 }

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,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

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;
 }