@smarthome.exchange/integrations 1.0.0 → 2.0.0

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

@@ -1,5 +1,10 @@
-import { SimpleLocalConfigFlow } from '../../core/index.js';
-import type { IOnkyoConfig } from './onkyo.types.js';
-export declare class OnkyoConfigFlow extends SimpleLocalConfigFlow<IOnkyoConfig> {
-    constructor();
+import { type NativeIntegrationScope } from '../../core/classes.nativeintegrationowner.js';
+import type { IConfigFlow, IConfigFlowStep, IDiscoveryCandidate, INativeConfigFlowContext } from '../../core/types.js';
+import type { IOnkyoConfig, IOnkyoIntegrationOptions } from './onkyo.types.js';
+export declare class OnkyoConfigFlow implements IConfigFlow<IOnkyoConfig> {
+    #private;
+    constructor(optionsArg?: IOnkyoIntegrationOptions, scopeArg?: NativeIntegrationScope);
+    start(candidateArg: IDiscoveryCandidate, contextArg: INativeConfigFlowContext): Promise<IConfigFlowStep<IOnkyoConfig>>;
+    destroy(): Promise<void>;
+    retryCleanup(): Promise<void>;
 }

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

@@ -1,8 +1,53 @@
-import { SimpleLocalConfigFlow } from '../../core/index.js';
-import { onkyoProfile } from './onkyo.types.js';
-export class OnkyoConfigFlow extends SimpleLocalConfigFlow {
-    constructor() {
-        super(onkyoProfile);
+import { NativeIntegrationOwner } from '../../core/classes.nativeintegrationowner.js';
+import { OnkyoClient } from './onkyo.classes.client.js';
+import { createOnkyoDiscoveryDescriptor } from './onkyo.discovery.js';
+import { normalizeOnkyoConfig, onkyoKeys, onkyoRecord } from './onkyo.validation.js';
+export class OnkyoConfigFlow {
+    #scope;
+    constructor(optionsArg = {}, scopeArg) {
+        this.#scope = scopeArg ?? new NativeIntegrationOwner('onkyo', optionsArg).createFlowScope();
     }
+    async start(candidateArg, contextArg) {
+        const context = this.#scope.admit(contextArg);
+        // The owned pure validator captures the selected candidate before yielding.
+        const validation = createOnkyoDiscoveryDescriptor().getValidators()[0].validate(candidateArg, {});
+        return this.#scope.run(context, undefined, async (leaseArg) => {
+            const matched = await validation;
+            leaseArg.assertOpen();
+            if (!matched.matched || !matched.candidate)
+                return { kind: 'error', error: matched.reason };
+            const candidate = matched.candidate;
+            return {
+                kind: 'form', title: 'Connect selected Onkyo main zone',
+                description: 'Acknowledge the cleartext LAN protocol and set an absolute raw-volume ceiling. Home, endpoint, MAC and model are fixed by the host and selected candidate.',
+                fields: [
+                    { name: 'allowUnencryptedLan', label: 'Acknowledge unauthenticated cleartext LAN', type: 'boolean', required: true },
+                    { name: 'volumeLimitRaw', label: 'Maximum integer raw volume (0–100)', type: 'number', required: true },
+                    { name: 'name', label: 'Name', type: 'text' },
+                ],
+                submit: async (valuesArg) => {
+                    try {
+                        const values = onkyoRecord(valuesArg, 'config flow values');
+                        onkyoKeys(values, ['homeId', 'allowUnencryptedLan', 'volumeLimitRaw', 'name', 'requestTimeoutMs', 'maxPendingOperations']);
+                        if (values.homeId !== undefined && values.homeId !== context.homeId)
+                            throw new TypeError('Onkyo submitted home must match the host-selected home.');
+                        const config = normalizeOnkyoConfig({ ...values, homeId: context.homeId, host: candidate.host, port: candidate.port, macAddress: candidate.macAddress, model: candidate.model });
+                        return await this.#scope.run(context, config.homeId, async (operationArg) => {
+                            const client = new OnkyoClient(config, operationArg.context, operationArg.signal);
+                            operationArg.own(() => client.destroy());
+                            await client.getSnapshot(operationArg.signal);
+                            operationArg.assertOpen();
+                            return { kind: 'done', title: 'Onkyo receiver validated', config };
+                        });
+                    }
+                    catch (errorArg) {
+                        return { kind: 'error', error: errorArg instanceof Error ? errorArg.message : 'Onkyo setup validation failed.' };
+                    }
+                },
+            };
+        });
+    }
+    destroy() { return this.#scope.close(); }
+    retryCleanup() { return this.#scope.retryCleanup(); }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25reW8uY2xhc3Nlcy5jb25maWdmbG93LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL29ua3lvL29ua3lvLmNsYXNzZXMuY29uZmlnZmxvdy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUU1RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFaEQsTUFBTSxPQUFPLGVBQWdCLFNBQVEscUJBQW1DO0lBQ3RFO1FBQ0UsS0FBSyxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQ3RCLENBQUM7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,12 +1,28 @@
-import { SimpleLocalIntegration, type IIntegrationRuntime, type IIntegrationSetupContext } from '../../core/index.js';
+import { BaseIntegration } from '../../core/classes.baseintegration.js';
+import type { IIntegrationRuntime, INativeIntegrationSetupContext } from '../../core/types.js';
 import { OnkyoConfigFlow } from './onkyo.classes.configflow.js';
-import type { IOnkyoConfig } from './onkyo.types.js';
-export declare class OnkyoIntegration extends SimpleLocalIntegration<IOnkyoConfig> {
+import type { IOnkyoConfig, IOnkyoIntegrationOptions } from './onkyo.types.js';
+export declare class OnkyoIntegration extends BaseIntegration<IOnkyoConfig> {
+    #private;
     readonly domain = "onkyo";
-    readonly discoveryDescriptor: import("../../core/classes.discoverydescriptor.js").DiscoveryDescriptor;
+    readonly displayName = "Onkyo";
+    readonly status: 'control-runtime';
+    readonly metadata: {
+        readonly source: 'home-assistant/core';
+        readonly upstreamDomain: "onkyo";
+        readonly configFlow: true;
+        readonly localApi: {
+            readonly status: 'Selected native Onkyo main-zone eISCP TCP through devicemanager.';
+            readonly implemented: readonly ['selected unicast UDP advertisement', 'live MAC/model and enabled main-zone admission', 'explicit power/mute, advertised input selectors and bounded absolute integer raw volume', 'explicit captured host home and optional actual caller-owned NoSQL store', 'events from explicit observations and joined terminal shutdown'];
+            readonly explicitUnsupported: readonly ['broadcast discovery', 'cloud access', 'injected clients and snapshots', 'other zones', 'percentage or half-step volume conversion', 'toggle/increment/media transport/arbitrary commands', 'automatic reconnect, effect retry or replay', 'unsolicited push subscription', 'cryptographic LAN peer authentication'];
+        };
+    };
+    readonly discoveryDescriptor: import("../../index.js").DiscoveryDescriptor;
     readonly configFlow: OnkyoConfigFlow;
-    constructor();
-    setup(configArg: IOnkyoConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime>;
+    constructor(optionsArg?: IOnkyoIntegrationOptions);
+    setup(configArg: IOnkyoConfig, contextArg: INativeIntegrationSetupContext): Promise<IIntegrationRuntime>;
+    destroy(): Promise<void>;
+    retryCleanup(): Promise<void>;
 }
 export declare class HomeAssistantOnkyoIntegration extends OnkyoIntegration {
 }

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

@@ -1,20 +1,153 @@
-import { SimpleLocalIntegration, SimpleLocalRuntime } 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 { OnkyoClient } from './onkyo.classes.client.js';
 import { OnkyoConfigFlow } from './onkyo.classes.configflow.js';
 import { createOnkyoDiscoveryDescriptor } from './onkyo.discovery.js';
-import { onkyoDomain, onkyoProfile } from './onkyo.types.js';
-export class OnkyoIntegration extends SimpleLocalIntegration {
-    domain = onkyoDomain;
+import { OnkyoMapper } from './onkyo.mapper.js';
+import { onkyoProfile } from './onkyo.types.js';
+import { normalizeOnkyoConfig, onkyoBoolean, onkyoInputId, onkyoInteger, onkyoKeys, onkyoRecord } from './onkyo.validation.js';
+export class OnkyoIntegration extends BaseIntegration {
+    domain = 'onkyo';
+    displayName = 'Onkyo';
+    status = 'control-runtime';
+    metadata = onkyoProfile.metadata;
     discoveryDescriptor = createOnkyoDiscoveryDescriptor();
-    configFlow = new OnkyoConfigFlow();
-    constructor() {
-        super(onkyoProfile);
+    configFlow;
+    #owner;
+    constructor(optionsArg = {}) {
+        super();
+        this.#owner = new NativeIntegrationOwner('onkyo', optionsArg);
+        this.configFlow = new OnkyoConfigFlow(optionsArg, this.#owner.createFlowScope());
     }
-    async setup(configArg, contextArg) {
-        void contextArg;
-        return new SimpleLocalRuntime(onkyoProfile, new OnkyoClient(configArg));
+    setup(configArg, contextArg) {
+        let config;
+        try {
+            config = normalizeOnkyoConfig(configArg);
+        }
+        catch (errorArg) {
+            return Promise.reject(errorArg);
+        }
+        return this.#owner.runSetup(contextArg, config.homeId, async (leaseArg) => {
+            const client = new OnkyoClient(config, leaseArg.context, leaseArg.signal);
+            leaseArg.own(() => client.destroy());
+            const snapshot = await client.getSnapshot(leaseArg.signal);
+            leaseArg.assertOpen();
+            const runtime = new OnkyoRuntime(client, snapshot, () => leaseArg.close());
+            leaseArg.promoteToRuntime();
+            return runtime;
+        });
     }
+    destroy() { return this.#owner.close(); }
+    retryCleanup() { return this.#owner.retryCleanup(); }
 }
 export class HomeAssistantOnkyoIntegration extends OnkyoIntegration {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25reW8uY2xhc3Nlcy5pbnRlZ3JhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy9vbmt5by9vbmt5by5jbGFzc2VzLmludGVncmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxrQkFBa0IsRUFBMkQsTUFBTSxxQkFBcUIsQ0FBQztBQUMxSSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ2hFLE9BQU8sRUFBRSw4QkFBOEIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRXRFLE9BQU8sRUFBRSxXQUFXLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFN0QsTUFBTSxPQUFPLGdCQUFpQixTQUFRLHNCQUFvQztJQUN4RCxNQUFNLEdBQUcsV0FBVyxDQUFDO0lBQ3JCLG1CQUFtQixHQUFHLDhCQUE4QixFQUFFLENBQUM7SUFDdkQsVUFBVSxHQUFHLElBQUksZUFBZSxFQUFFLENBQUM7SUFFbkQ7UUFDRSxLQUFLLENBQUMsWUFBWSxDQUFDLENBQUM7SUFDdEIsQ0FBQztJQUVNLEtBQUssQ0FBQyxLQUFLLENBQUMsU0FBdUIsRUFBRSxVQUFvQztRQUM5RSxLQUFLLFVBQVUsQ0FBQztRQUNoQixPQUFPLElBQUksa0JBQWtCLENBQUMsWUFBWSxFQUFFLElBQUksV0FBVyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7SUFDMUUsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLDZCQUE4QixTQUFRLGdCQUFnQjtDQUFHIn0=
+class OnkyoRuntime {
+    client;
+    closeLease;
+    domain = 'onkyo';
+    #deviceId;
+    #entityId;
+    #closePromise;
+    constructor(client, snapshotArg, closeLease) {
+        this.client = client;
+        this.closeLease = closeLease;
+        this.#deviceId = OnkyoMapper.deviceId(snapshotArg);
+        this.#entityId = OnkyoMapper.mediaEntityId(snapshotArg);
+    }
+    isHealthy() { return this.client.isHealthy(); }
+    async devices(signalArg) { return OnkyoMapper.toDevices(await this.client.getSnapshot(signalArg)); }
+    async entities() { return OnkyoMapper.toEntities(await this.client.getSnapshot()); }
+    async subscribe(handlerArg, signalArg) {
+        if (typeof handlerArg !== 'function')
+            throw new TypeError('Onkyo runtime subscriber must be a function.');
+        const unsubscribe = this.client.subscribe((eventArg) => {
+            const event = {
+                type: eventArg.type === 'error' ? 'error' : 'state_changed', integrationDomain: 'onkyo', deviceId: this.#deviceId,
+                entityId: this.#entityId, timestamp: Date.now(),
+                data: eventArg.type === 'snapshot' ? { snapshot: eventArg.snapshot, entity: OnkyoMapper.toEntities(eventArg.snapshot)[0] } :
+                    eventArg.type === 'control' ? { observation: eventArg.observation } : { message: eventArg.error.message },
+            };
+            handlerArg(event);
+        }, signalArg);
+        return async () => unsubscribe();
+    }
+    async callService(requestArg) {
+        try {
+            const request = onkyoRecord(requestArg, 'service request');
+            onkyoKeys(request, ['domain', 'service', 'target', 'data']);
+            if (typeof request.domain !== 'string' || typeof request.service !== 'string')
+                throw new TypeError('Onkyo service domain and service must be strings.');
+            this.#assertTarget(request.target);
+            const data = request.data === undefined ? {} : onkyoRecord(request.data, 'service data');
+            if (request.domain === 'onkyo' && ['status', 'snapshot', 'refresh'].includes(request.service)) {
+                onkyoKeys(data, []);
+                return { success: true, data: await this.client.getSnapshot() };
+            }
+            if (request.domain !== 'onkyo' && request.domain !== 'media_player')
+                throw new TypeError('Onkyo service domain is unsupported.');
+            if (request.service === 'set_power') {
+                onkyoKeys(data, ['power']);
+                return observed(await this.client.setPower(onkyoBoolean(data.power, 'power')));
+            }
+            if (request.service === 'set_mute' || request.service === 'volume_mute') {
+                onkyoKeys(data, ['muted']);
+                return observed(await this.client.setMuted(onkyoBoolean(data.muted, 'mute')));
+            }
+            if (request.service === 'set_volume_raw') {
+                onkyoKeys(data, ['volumeRaw']);
+                return observed(await this.client.setVolume(onkyoInteger(data.volumeRaw, 0, 100, 'raw volume')));
+            }
+            if (request.service === 'set_input' || request.service === 'select_source') {
+                onkyoKeys(data, ['inputId']);
+                return observed(await this.client.setInput(onkyoInputId(data.inputId)));
+            }
+            throw new TypeError('Onkyo service is unsupported.');
+        }
+        catch (errorArg) {
+            return failed(errorArg);
+        }
+    }
+    async writeFeature(requestArg, signalArg) {
+        try {
+            const request = onkyoRecord(requestArg, 'feature write');
+            onkyoKeys(request, ['device', 'feature', 'value']);
+            const device = onkyoRecord(request.device, 'feature device');
+            const feature = onkyoRecord(request.feature, 'feature');
+            if (device.id !== this.#deviceId || device.integrationDomain !== 'onkyo')
+                throw new TypeError('Onkyo feature device is not owned by this home runtime.');
+            if (typeof feature.id !== 'string')
+                throw new TypeError('Onkyo feature id must be a string.');
+            const value = request.value;
+            if (typeof value !== 'boolean' && typeof value !== 'number' && typeof value !== 'string')
+                throw new TypeError('Onkyo control requires an explicit primitive value.');
+            return observed(await this.client.writeFeature(feature.id, value, signalArg));
+        }
+        catch (errorArg) {
+            return failed(errorArg);
+        }
+    }
+    destroy() {
+        this.#closePromise ??= Promise.resolve().then(() => this.closeLease());
+        return this.#closePromise;
+    }
+    #assertTarget(valueArg) {
+        const target = onkyoRecord(valueArg, 'service target');
+        onkyoKeys(target, ['deviceId', 'entityId']);
+        if (target.deviceId === undefined && target.entityId === undefined ||
+            target.deviceId !== undefined && target.deviceId !== this.#deviceId ||
+            target.entityId !== undefined && target.entityId !== this.#entityId)
+            throw new TypeError('Onkyo services require an exact owned device or main-zone entity target.');
+    }
+}
+function observed(observationArg) {
+    return { success: true, data: { ...observationArg } };
+}
+function failed(errorArg) {
+    return { success: false, error: errorArg instanceof Error ? errorArg.message : 'Onkyo operation failed.', data: {
+            effectOutcome: errorArg instanceof plugins.ecobridgeDeviceManager.OnkyoProtocolError ? errorArg.effectOutcome : 'not-sent',
+            code: errorArg instanceof plugins.ecobridgeDeviceManager.OnkyoProtocolError ? errorArg.code : 'INVALID_OPERATION',
+        } };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"onkyo.classes.integration.js","sourceRoot":"","sources":["../../../ts/integrations/onkyo/onkyo.classes.integration.ts"],"names":[],"mappings":"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"}

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

@@ -1 +1,6 @@
-export declare const createOnkyoDiscoveryDescriptor: () => import("../../core/classes.discoverydescriptor.js").DiscoveryDescriptor;
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import type { IDiscoveryCandidate } from '../../core/types.js';
+import type { IOnkyoSelectedProbeOptions } from './onkyo.types.js';
+export declare function createOnkyoDiscoveryDescriptor(): DiscoveryDescriptor;
+/** One explicitly selected unicast UDP probe; TCP setup still validates the chosen identity. */
+export declare function probeSelectedOnkyo(optionsArg: IOnkyoSelectedProbeOptions): Promise<IDiscoveryCandidate>;

package/dist_ts/integrations/onkyo/onkyo.discovery.js

@@ -1,4 +1,40 @@
-import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
-import { onkyoProfile } from './onkyo.types.js';
-export const createOnkyoDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(onkyoProfile);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25reW8uZGlzY292ZXJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL29ua3lvL29ua3lvLmRpc2NvdmVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0NBQW9DLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUMzRSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFaEQsTUFBTSxDQUFDLE1BQU0sOEJBQThCLEdBQUcsR0FBRyxFQUFFLENBQUMsb0NBQW9DLENBQUMsWUFBWSxDQUFDLENBQUMifQ==
+import * as plugins from '../../plugins.js';
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import { onkyoHost, onkyoInteger, onkyoKeys, onkyoName, onkyoRecord, readOnkyoEndpoint } from './onkyo.validation.js';
+function matchCandidate(valueArg) {
+    try {
+        const input = onkyoRecord(valueArg, 'discovery candidate');
+        if (input.source !== 'manual' && input.source !== 'custom' || input.integrationDomain !== 'onkyo') {
+            return { matched: false, confidence: 'low', reason: 'An explicit manual/custom Onkyo candidate is required.' };
+        }
+        const candidate = {
+            source: input.source, integrationDomain: 'onkyo', ...readOnkyoEndpoint(input.host, input.macAddress, input.model, input.port),
+            name: input.name === undefined ? undefined : onkyoName(input.name, 'candidate name'),
+        };
+        return { matched: true, confidence: 'medium', reason: 'Explicit endpoint/MAC/model binding; live identity and main zone are checked during setup.', candidate };
+    }
+    catch (errorArg) {
+        return { matched: false, confidence: 'low', reason: errorArg instanceof Error ? errorArg.message : 'Invalid Onkyo candidate.' };
+    }
+}
+export function createOnkyoDiscoveryDescriptor() {
+    return new DiscoveryDescriptor({ integrationDomain: 'onkyo', displayName: 'Onkyo' })
+        .addMatcher({ id: 'onkyo-manual-match', source: 'manual', matches: async (inputArg) => matchCandidate(inputArg) })
+        .addMatcher({ id: 'onkyo-custom-match', source: 'custom', matches: async (inputArg) => matchCandidate(inputArg) })
+        .addValidator({ id: 'onkyo-explicit-endpoint', validate: async (candidateArg) => matchCandidate(candidateArg) });
+}
+/** One explicitly selected unicast UDP probe; TCP setup still validates the chosen identity. */
+export async function probeSelectedOnkyo(optionsArg) {
+    const options = onkyoRecord(optionsArg, 'selected probe options');
+    onkyoKeys(options, ['host', 'port', 'requestTimeoutMs', 'signal']);
+    if (options.signal !== undefined && !(options.signal instanceof AbortSignal))
+        throw new TypeError('Onkyo probe signal must be an AbortSignal.');
+    const advertisement = await plugins.ecobridgeDeviceManager.probeOnkyo({
+        address: onkyoHost(options.host), port: options.port === undefined ? undefined : onkyoInteger(options.port, 1, 65535, 'probe port'),
+        timeoutMs: options.requestTimeoutMs === undefined ? undefined : onkyoInteger(options.requestTimeoutMs, 1, 60000, 'probe deadline'),
+        signal: options.signal,
+    });
+    return { source: 'custom', integrationDomain: 'onkyo', host: advertisement.address, port: advertisement.port,
+        model: advertisement.model, macAddress: advertisement.macAddress, manufacturer: 'Onkyo', metadata: { area: advertisement.area } };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,10 +1,9 @@
-import type * as shxInterfaces from '@smarthome.exchange/interfaces';
-import { type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
-import type { IOnkyoConfig } from './onkyo.types.js';
+import type * as plugins from '../../plugins.js';
+import type { IIntegrationEntity } from '../../core/types.js';
+import type { IOnkyoSnapshot } from './onkyo.types.js';
 export declare class OnkyoMapper {
-    static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IOnkyoConfig>, 'profile'>): ISimpleLocalSnapshot;
-    static toSnapshotFromRaw(configArg: IOnkyoConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot;
-    static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[];
-    static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[];
-    static slug(valueArg: unknown): string;
+    static deviceId(snapshotArg: Pick<IOnkyoSnapshot, 'homeId' | 'receiver'>): string;
+    static mediaEntityId(snapshotArg: Pick<IOnkyoSnapshot, 'homeId' | 'receiver'>): string;
+    static toDevices(snapshotArg: IOnkyoSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[];
+    static toEntities(snapshotArg: IOnkyoSnapshot): IIntegrationEntity[];
 }

package/dist_ts/integrations/onkyo/onkyo.mapper.js

@@ -1,20 +1,53 @@
-import { SimpleLocalMapper } from '../../core/index.js';
-import { onkyoProfile } from './onkyo.types.js';
 export class OnkyoMapper {
-    static toSnapshot(optionsArg) {
-        return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: onkyoProfile });
+    static deviceId(snapshotArg) {
+        return `onkyo:${encodeURIComponent(snapshotArg.homeId)}:${snapshotArg.receiver.macAddress}`;
     }
-    static toSnapshotFromRaw(configArg, rawDataArg) {
-        return SimpleLocalMapper.toSnapshot({ profile: onkyoProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+    static mediaEntityId(snapshotArg) {
+        return `${this.deviceId(snapshotArg)}:main`;
     }
     static toDevices(snapshotArg) {
-        return SimpleLocalMapper.toDevices(onkyoProfile, snapshotArg);
+        const receiver = snapshotArg.receiver;
+        const features = [
+            { id: 'connectivity', capability: 'sensor', name: 'Connectivity', readable: true, writable: false },
+            { id: 'identity', capability: 'sensor', name: 'Receiver identity', readable: true, writable: false },
+            { id: 'inputs', capability: 'sensor', name: 'Advertised main-zone inputs', readable: true, writable: false },
+        ];
+        const state = [
+            { featureId: 'connectivity', value: 'online', updatedAt: snapshotArg.observedAt },
+            { featureId: 'identity', value: { macAddress: receiver.macAddress, model: receiver.model, brand: receiver.brand }, updatedAt: snapshotArg.observedAt },
+            { featureId: 'inputs', value: { inputs: receiver.inputs.map((inputArg) => ({ ...inputArg })) }, updatedAt: snapshotArg.observedAt },
+        ];
+        const add = (idArg, nameArg, valueArg, writableArg, unitArg) => {
+            features.push({ id: idArg, capability: 'media', name: nameArg, readable: true, writable: writableArg, ...(unitArg ? { unit: unitArg } : {}) });
+            state.push({ featureId: idArg, value: valueArg, updatedAt: snapshotArg.observedAt });
+        };
+        if (snapshotArg.power !== undefined)
+            add('power', 'Power', snapshotArg.power, true);
+        if (snapshotArg.muted !== undefined)
+            add('mute', 'Mute', snapshotArg.muted, true);
+        if (snapshotArg.volumeRaw !== undefined)
+            add('volume_raw', 'Absolute raw volume', snapshotArg.volumeRaw, receiver.integerVolumeMaximum !== undefined && snapshotArg.volumeRaw <= receiver.integerVolumeMaximum, 'receiver raw units');
+        if (snapshotArg.inputId !== undefined)
+            add('input', 'Input selector', snapshotArg.inputId, receiver.inputs.length > 0);
+        return [{
+                id: this.deviceId(snapshotArg), integrationDomain: 'onkyo', name: snapshotArg.name, manufacturer: 'Onkyo',
+                model: receiver.model, protocol: 'tcp', online: snapshotArg.online, features, state,
+                metadata: { homeId: snapshotArg.homeId, macAddress: receiver.macAddress, zone: 'main', wireProtocol: 'eiscp', lanAuthenticated: false,
+                    inputs: receiver.inputs.map((inputArg) => ({ ...inputArg })), integerVolumeMaximum: receiver.integerVolumeMaximum,
+                    volumeLimitRaw: snapshotArg.volumeLimitRaw,
+                    ...(receiver.integerVolumeMaximum === undefined ? {} : { volumeRange: { minimumRaw: 0, maximumRaw: Math.min(receiver.integerVolumeMaximum, snapshotArg.volumeLimitRaw) } }),
+                    observedAt: snapshotArg.observedAt },
+            }];
     }
     static toEntities(snapshotArg) {
-        return SimpleLocalMapper.toEntities(onkyoProfile, snapshotArg);
-    }
-    static slug(valueArg) {
-        return SimpleLocalMapper.slug(valueArg);
+        return [{
+                id: this.mediaEntityId(snapshotArg), uniqueId: this.mediaEntityId(snapshotArg), deviceId: this.deviceId(snapshotArg),
+                integrationDomain: 'onkyo', platform: 'media_player', name: snapshotArg.name,
+                state: snapshotArg.power === undefined ? 'unknown' : snapshotArg.power ? 'on' : 'off', available: snapshotArg.online,
+                attributes: { power: snapshotArg.power, muted: snapshotArg.muted, volumeRaw: snapshotArg.volumeRaw, inputId: snapshotArg.inputId,
+                    inputs: snapshotArg.receiver.inputs.map((inputArg) => ({ ...inputArg })), integerVolumeMaximum: snapshotArg.receiver.integerVolumeMaximum,
+                    volumeLimitRaw: snapshotArg.volumeLimitRaw, zone: 'main', observedAt: snapshotArg.observedAt },
+            }];
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25reW8ubWFwcGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL29ua3lvL29ua3lvLm1hcHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsaUJBQWlCLEVBQWtILE1BQU0scUJBQXFCLENBQUM7QUFFeEssT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRWhELE1BQU0sT0FBTyxXQUFXO0lBQ2YsTUFBTSxDQUFDLFVBQVUsQ0FBQyxVQUFzRTtRQUM3RixPQUFPLGlCQUFpQixDQUFDLFVBQVUsQ0FBQyxFQUFFLEdBQUcsVUFBVSxFQUFFLE9BQU8sRUFBRSxZQUFZLEVBQUUsQ0FBQyxDQUFDO0lBQ2hGLENBQUM7SUFFTSxNQUFNLENBQUMsaUJBQWlCLENBQUMsU0FBdUIsRUFBRSxVQUErQjtRQUN0RixPQUFPLGlCQUFpQixDQUFDLFVBQVUsQ0FBQyxFQUFFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDekksQ0FBQztJQUVNLE1BQU0sQ0FBQyxTQUFTLENBQUMsV0FBaUM7UUFDdkQsT0FBTyxpQkFBaUIsQ0FBQyxTQUFTLENBQUMsWUFBWSxFQUFFLFdBQVcsQ0FBQyxDQUFDO0lBQ2hFLENBQUM7SUFFTSxNQUFNLENBQUMsVUFBVSxDQUFDLFdBQWlDO1FBQ3hELE9BQU8saUJBQWlCLENBQUMsVUFBVSxDQUFDLFlBQVksRUFBRSxXQUFXLENBQUMsQ0FBQztJQUNqRSxDQUFDO0lBRU0sTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFpQjtRQUNsQyxPQUFPLGlCQUFpQixDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUMxQyxDQUFDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25reW8ubWFwcGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL29ua3lvL29ua3lvLm1hcHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLE9BQU8sV0FBVztJQUNmLE1BQU0sQ0FBQyxRQUFRLENBQUMsV0FBd0Q7UUFDN0UsT0FBTyxTQUFTLGtCQUFrQixDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsSUFBSSxXQUFXLENBQUMsUUFBUSxDQUFDLFVBQVUsRUFBRSxDQUFDO0lBQzlGLENBQUM7SUFDTSxNQUFNLENBQUMsYUFBYSxDQUFDLFdBQXdEO1FBQ2xGLE9BQU8sR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxPQUFPLENBQUM7SUFDOUMsQ0FBQztJQUNNLE1BQU0sQ0FBQyxTQUFTLENBQUMsV0FBMkI7UUFDakQsTUFBTSxRQUFRLEdBQUcsV0FBVyxDQUFDLFFBQVEsQ0FBQztRQUN0QyxNQUFNLFFBQVEsR0FBZ0Q7WUFDNUQsRUFBRSxFQUFFLEVBQUUsY0FBYyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLGNBQWMsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxLQUFLLEVBQUU7WUFDbkcsRUFBRSxFQUFFLEVBQUUsVUFBVSxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLG1CQUFtQixFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLEtBQUssRUFBRTtZQUNwRyxFQUFFLEVBQUUsRUFBRSxRQUFRLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsNkJBQTZCLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFO1NBQzdHLENBQUM7UUFDRixNQUFNLEtBQUssR0FBOEM7WUFDdkQsRUFBRSxTQUFTLEVBQUUsY0FBYyxFQUFFLEtBQUssRUFBRSxRQUFRLEVBQUUsU0FBUyxFQUFFLFdBQVcsQ0FBQyxVQUFVLEVBQUU7WUFDakYsRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBRSxFQUFFLFVBQVUsRUFBRSxRQUFRLENBQUMsVUFBVSxFQUFFLEtBQUssRUFBRSxRQUFRLENBQUMsS0FBSyxFQUFFLEtBQUssRUFBRSxRQUFRLENBQUMsS0FBSyxFQUFFLEVBQUUsU0FBUyxFQUFFLFdBQVcsQ0FBQyxVQUFVLEVBQUU7WUFDdEosRUFBRSxTQUFTLEVBQUUsUUFBUSxFQUFFLEtBQUssRUFBRSxFQUFFLE1BQU0sRUFBRSxRQUFRLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLFFBQVEsRUFBRSxFQUFFLENBQUMsQ0FBQyxFQUFFLEdBQUcsUUFBUSxFQUFFLENBQUMsQ0FBQyxFQUFFLEVBQUUsU0FBUyxFQUFFLFdBQVcsQ0FBQyxVQUFVLEVBQUU7U0FDcEksQ0FBQztRQUNGLE1BQU0sR0FBRyxHQUFHLENBQUMsS0FBYSxFQUFFLE9BQWUsRUFBRSxRQUFtQyxFQUFFLFdBQW9CLEVBQUUsT0FBZ0IsRUFBUSxFQUFFO1lBQ2hJLFFBQVEsQ0FBQyxJQUFJLENBQUMsRUFBRSxFQUFFLEVBQUUsS0FBSyxFQUFFLFVBQVUsRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxXQUFXLEVBQUUsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQztZQUMvSSxLQUFLLENBQUMsSUFBSSxDQUFDLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLFNBQVMsRUFBRSxXQUFXLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQztRQUN2RixDQUFDLENBQUM7UUFDRixJQUFJLFdBQVcsQ0FBQyxLQUFLLEtBQUssU0FBUztZQUFFLEdBQUcsQ0FBQyxPQUFPLEVBQUUsT0FBTyxFQUFFLFdBQVcsQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFDcEYsSUFBSSxXQUFXLENBQUMsS0FBSyxLQUFLLFNBQVM7WUFBRSxHQUFHLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxXQUFXLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQ2xGLElBQUksV0FBVyxDQUFDLFNBQVMsS0FBSyxTQUFTO1lBQUUsR0FBRyxDQUFDLFlBQVksRUFBRSxxQkFBcUIsRUFBRSxXQUFXLENBQUMsU0FBUyxFQUNyRyxRQUFRLENBQUMsb0JBQW9CLEtBQUssU0FBUyxJQUFJLFdBQVcsQ0FBQyxTQUFTLElBQUksUUFBUSxDQUFDLG9CQUFvQixFQUFFLG9CQUFvQixDQUFDLENBQUM7UUFDL0gsSUFBSSxXQUFXLENBQUMsT0FBTyxLQUFLLFNBQVM7WUFBRSxHQUFHLENBQUMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLFdBQVcsQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLE1BQU0sQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUM7UUFDdkgsT0FBTyxDQUFDO2dCQUNOLEVBQUUsRUFBRSxJQUFJLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxFQUFFLGlCQUFpQixFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsV0FBVyxDQUFDLElBQUksRUFBRSxZQUFZLEVBQUUsT0FBTztnQkFDekcsS0FBSyxFQUFFLFFBQVEsQ0FBQyxLQUFLLEVBQUUsUUFBUSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsV0FBVyxDQUFDLE1BQU0sRUFBRSxRQUFRLEVBQUUsS0FBSztnQkFDbkYsUUFBUSxFQUFFLEVBQUUsTUFBTSxFQUFFLFdBQVcsQ0FBQyxNQUFNLEVBQUUsVUFBVSxFQUFFLFFBQVEsQ0FBQyxVQUFVLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxZQUFZLEVBQUUsT0FBTyxFQUFFLGdCQUFnQixFQUFFLEtBQUs7b0JBQ25JLE1BQU0sRUFBRSxRQUFRLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLFFBQVEsRUFBRSxFQUFFLENBQUMsQ0FBQyxFQUFFLEdBQUcsUUFBUSxFQUFFLENBQUMsQ0FBQyxFQUFFLG9CQUFvQixFQUFFLFFBQVEsQ0FBQyxvQkFBb0I7b0JBQ2pILGNBQWMsRUFBRSxXQUFXLENBQUMsY0FBYztvQkFDMUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxvQkFBb0IsS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxXQUFXLEVBQUUsRUFBRSxVQUFVLEVBQUUsQ0FBQyxFQUFFLFVBQVUsRUFBRSxJQUFJLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxvQkFBb0IsRUFBRSxXQUFXLENBQUMsY0FBYyxDQUFDLEVBQUUsRUFBRSxDQUFDO29CQUMzSyxVQUFVLEVBQUUsV0FBVyxDQUFDLFVBQVUsRUFBRTthQUN2QyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBQ00sTUFBTSxDQUFDLFVBQVUsQ0FBQyxXQUEyQjtRQUNsRCxPQUFPLENBQUM7Z0JBQ04sRUFBRSxFQUFFLElBQUksQ0FBQyxhQUFhLENBQUMsV0FBVyxDQUFDLEVBQUUsUUFBUSxFQUFFLElBQUksQ0FBQyxhQUFhLENBQUMsV0FBVyxDQUFDLEVBQUUsUUFBUSxFQUFFLElBQUksQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUFDO2dCQUNwSCxpQkFBaUIsRUFBRSxPQUFPLEVBQUUsUUFBUSxFQUFFLGNBQWMsRUFBRSxJQUFJLEVBQUUsV0FBVyxDQUFDLElBQUk7Z0JBQzVFLEtBQUssRUFBRSxXQUFXLENBQUMsS0FBSyxLQUFLLFNBQVMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxXQUFXLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEtBQUssRUFBRSxTQUFTLEVBQUUsV0FBVyxDQUFDLE1BQU07Z0JBQ3BILFVBQVUsRUFBRSxFQUFFLEtBQUssRUFBRSxXQUFXLENBQUMsS0FBSyxFQUFFLEtBQUssRUFBRSxXQUFXLENBQUMsS0FBSyxFQUFFLFNBQVMsRUFBRSxXQUFXLENBQUMsU0FBUyxFQUFFLE9BQU8sRUFBRSxXQUFXLENBQUMsT0FBTztvQkFDOUgsTUFBTSxFQUFFLFdBQVcsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLFFBQVEsRUFBRSxFQUFFLENBQUMsQ0FBQyxFQUFFLEdBQUcsUUFBUSxFQUFFLENBQUMsQ0FBQyxFQUFFLG9CQUFvQixFQUFFLFdBQVcsQ0FBQyxRQUFRLENBQUMsb0JBQW9CO29CQUN6SSxjQUFjLEVBQUUsV0FBVyxDQUFDLGNBQWMsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxXQUFXLENBQUMsVUFBVSxFQUFFO2FBQ2pHLENBQUMsQ0FBQztJQUNMLENBQUM7Q0FDRiJ9

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

@@ -1,16 +1,66 @@
-import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+import type * as plugins from '../../plugins.js';
 export declare const onkyoDomain = "onkyo";
 export declare const onkyoDefaultName = "Onkyo";
 export declare const onkyoDefaultPort = 60128;
 export declare const onkyoDefaultTimeoutMs = 5000;
-export type TOnkyoRawData = TSimpleLocalRawData;
-export interface IOnkyoSnapshot extends ISimpleLocalSnapshot {
+export interface IOnkyoIntegrationOptions {
+    /** A consistency binding; setup and flow still require explicit host home. */
+    readonly homeId?: string;
+    /** Shared pending/runtime/flow/retained-cleanup capacity; defaults to 16. */
+    readonly capacity?: number;
 }
-export interface IOnkyoConfig extends ISimpleLocalConfig {
-    url?: string;
-    macAddress?: string;
-    deviceId?: string;
+export interface IOnkyoConfig {
+    homeId: string;
+    host: string;
+    macAddress: string;
+    model: string;
+    /** The selected identity does not authenticate the cleartext LAN peer. */
+    allowUnencryptedLan: true;
+    /** Absolute integer receiver units; no percent or half-step conversion. */
+    volumeLimitRaw: number;
+    port?: number;
+    name?: string;
+    requestTimeoutMs?: number;
+    maxPendingOperations?: number;
 }
 export interface IHomeAssistantOnkyoConfig extends IOnkyoConfig {
 }
-export declare const onkyoProfile: ISimpleLocalIntegrationProfile;
+/** Sequential live observations, never an injectable production data source. */
+export interface IOnkyoSnapshot extends plugins.ecobridgeDeviceManager.IOnkyoState {
+    readonly homeId: string;
+    readonly name: string;
+    readonly volumeLimitRaw: number;
+    readonly online: true;
+}
+export type TOnkyoRawData = IOnkyoSnapshot;
+export type TOnkyoClientEvent = {
+    type: 'snapshot';
+    snapshot: IOnkyoSnapshot;
+} | {
+    type: 'control';
+    observation: plugins.ecobridgeDeviceManager.IOnkyoControlObservation;
+} | {
+    type: 'error';
+    error: Error;
+};
+export interface IOnkyoSelectedProbeOptions {
+    host: string;
+    port?: number;
+    requestTimeoutMs?: number;
+    signal?: AbortSignal;
+}
+export declare const onkyoProfile: {
+    readonly domain: "onkyo";
+    readonly displayName: "Onkyo";
+    readonly status: 'control-runtime';
+    readonly metadata: {
+        readonly source: 'home-assistant/core';
+        readonly upstreamDomain: "onkyo";
+        readonly configFlow: true;
+        readonly localApi: {
+            readonly status: 'Selected native Onkyo main-zone eISCP TCP through devicemanager.';
+            readonly implemented: readonly ['selected unicast UDP advertisement', 'live MAC/model and enabled main-zone admission', 'explicit power/mute, advertised input selectors and bounded absolute integer raw volume', 'explicit captured host home and optional actual caller-owned NoSQL store', 'events from explicit observations and joined terminal shutdown'];
+            readonly explicitUnsupported: readonly ['broadcast discovery', 'cloud access', 'injected clients and snapshots', 'other zones', 'percentage or half-step volume conversion', 'toggle/increment/media transport/arbitrary commands', 'automatic reconnect, effect retry or replay', 'unsolicited push subscription', 'cryptographic LAN peer authentication'];
+        };
+    };
+};