@smarthome.exchange/integrations 0.2.0 → 2.0.0

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

@@ -1,8 +1,164 @@
-import { SimpleLocalClient } from '../../core/index.js';
-import { yamahaProfile } from './yamaha.types.js';
-export class YamahaClient extends SimpleLocalClient {
-    constructor(configArg) {
-        super(yamahaProfile, configArg);
+import * as plugins from '../../plugins.js';
+import { NativeHomeAdmission } from '../../core/classes.nativehomeadmission.js';
+import { assertYamahaScope, normalizeYamahaConfig, validateYamahaControl } from './yamaha.validation.js';
+/** The published protocol owns wire behavior; this facade owns exact home admission and caller work. */
+export class YamahaClient {
+    config;
+    context;
+    protocol;
+    lifetime = new AbortController();
+    operationTail = Promise.resolve();
+    pendingOperations = 0;
+    startPromise;
+    snapshot;
+    healthy = false;
+    closePromise;
+    retryPromise;
+    constructor(config, context) {
+        this.config = normalizeYamahaConfig(config);
+        this.context = new NativeHomeAdmission('yamaha').admit(context, this.config.homeId);
+        this.protocol = new plugins.ecobridgeDeviceManager.YamahaProtocol({ origin: this.config.origin,
+            expectedDeviceId: this.config.expectedDeviceId, expectedModel: this.config.model,
+            allowUnencryptedHttp: this.config.allowUnencryptedHttp, maxVolume: this.config.maxVolume,
+            timeoutMs: this.config.timeoutMs, maxResponseBytes: this.config.maxResponseBytes, maxPendingOperations: this.config.maxPendingOperations });
+    }
+    isHealthy() { return !this.lifetime.signal.aborted && !this.context.abortSignal?.aborted && this.healthy && this.protocol.isStarted; }
+    start(signal) {
+        try {
+            this.assertOpen();
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        if (!this.startPromise) {
+            this.startPromise = this.run(async (operationSignal, timeoutMs) => this.observe(await this.protocol.start({ signal: operationSignal, timeoutMs })), signal, false).catch(async (error) => {
+                this.lifetime.abort(error);
+                try {
+                    await this.protocol.close();
+                }
+                catch (cleanupError) {
+                    throw new AggregateError([error, cleanupError], 'Yamaha startup and cleanup failed.');
+                }
+                throw error;
+            });
+        }
+        return this.startPromise;
+    }
+    getObservedSnapshot() {
+        this.assertOpen();
+        if (!this.snapshot)
+            throw new Error('Yamaha has no admitted observation.');
+        return this.snapshot;
+    }
+    getSnapshot(signal) {
+        return this.run(async (operationSignal, timeoutMs) => this.observe(await this.protocol.readState({ signal: operationSignal, timeoutMs })), signal);
+    }
+    setControl(value, signal) {
+        const control = validateYamahaControl(value);
+        if (control.feature === 'volume_raw' && control.value > this.config.maxVolume)
+            throw new RangeError('Yamaha volume exceeds the owner ceiling.');
+        return this.run(async (operationSignal, timeoutMs) => {
+            const options = { signal: operationSignal, timeoutMs };
+            const result = control.feature === 'power' ? await this.protocol.setPower(control.value, options)
+                : control.feature === 'muted' ? await this.protocol.setMute(control.value, options)
+                    : control.feature === 'volume_raw' ? await this.protocol.setVolume(control.value, options)
+                        : await this.protocol.setInput(control.value, options);
+            try {
+                return Object.freeze({ dispatch: result.dispatch, outcome: result.outcome, snapshot: this.observe(result.observation) });
+            }
+            catch {
+                throw new plugins.ecobridgeDeviceManager.YamahaProtocolError('Yamaha observation could not be admitted after dispatch.', 'identity-mismatch', 'indeterminate');
+            }
+        }, signal);
+    }
+    destroy() {
+        if (!this.closePromise) {
+            this.healthy = false;
+            this.closePromise = Promise.resolve().then(() => this.drain());
+            this.lifetime.abort(new Error('Yamaha client is closed.'));
+        }
+        return this.closePromise;
+    }
+    /** Explicitly retries cleanup of this terminal client, without replaying receiver work. */
+    retryCleanup() {
+        if (!this.closePromise)
+            return Promise.reject(new Error('Yamaha cleanup retry requires a closed client.'));
+        if (!this.retryPromise) {
+            const retry = Promise.resolve().then(() => this.drain());
+            this.retryPromise = retry;
+            const settled = () => { this.retryPromise = undefined; };
+            void retry.then(settled, settled);
+        }
+        return this.retryPromise;
+    }
+    async drain() {
+        const results = await Promise.allSettled([
+            Promise.resolve().then(() => this.protocol.close()), this.operationTail, this.startPromise,
+        ]);
+        this.snapshot = undefined;
+        const closure = results[0];
+        if (closure.status === 'rejected')
+            throw closure.reason;
+    }
+    observe(state) {
+        this.assertOpen();
+        this.snapshot = Object.freeze({ homeId: this.context.homeId, origin: this.config.origin,
+            name: this.config.name ?? 'Yamaha RX-V485 main zone', identity: Object.freeze({ ...state.identity }),
+            power: state.power, muted: state.muted, volume: state.volume, receiverMaxVolume: state.maxVolume,
+            ownerMaxVolume: this.config.maxVolume, input: state.input, inputs: Object.freeze([...state.capabilities.inputs]),
+            volumeRange: Object.freeze({ ...state.capabilities.volumeRange }), observedAt: state.observedAt });
+        this.healthy = true;
+        return this.snapshot;
+    }
+    assertOpen() {
+        this.lifetime.signal.throwIfAborted();
+        if (this.context.abortSignal)
+            AbortSignal.prototype.throwIfAborted.call(this.context.abortSignal);
+        assertYamahaScope(this.context.configStore, this.context.homeId);
+    }
+    /** Validate scope when adapter work runs; its single deadline includes waiting for earlier calls. */
+    run(execute, signal, started = true) {
+        try {
+            this.assertOpen();
+            if (signal !== undefined && !(signal instanceof AbortSignal))
+                throw new TypeError('Yamaha cancellation requires an AbortSignal.');
+            signal?.throwIfAborted();
+            if (started && !this.protocol.isStarted)
+                throw new Error('Yamaha client has not started.');
+            if (this.pendingOperations >= this.config.maxPendingOperations)
+                throw new Error('Yamaha operation capacity reached.');
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        const deadline = performance.now() + this.config.timeoutMs;
+        const controller = new AbortController();
+        const combined = AbortSignal.any([this.lifetime.signal, controller.signal,
+            ...(this.context.abortSignal ? [this.context.abortSignal] : []), ...(signal ? [signal] : [])]);
+        const timer = setTimeout(() => controller.abort(new plugins.ecobridgeDeviceManager.YamahaProtocolError('Yamaha operation deadline expired.', 'timeout')), this.config.timeoutMs);
+        this.pendingOperations++;
+        let rejectWaiting = () => { };
+        const waitingCancelled = new Promise((_resolve, reject) => {
+            rejectWaiting = () => reject(combined.reason);
+            combined.addEventListener('abort', rejectWaiting, { once: true });
+        });
+        const operation = this.operationTail.then(async () => {
+            combined.removeEventListener('abort', rejectWaiting);
+            combined.throwIfAborted();
+            this.assertOpen();
+            const remaining = Math.floor(deadline - performance.now());
+            if (remaining < 1)
+                throw new plugins.ecobridgeDeviceManager.YamahaProtocolError('Yamaha queued operation expired.', 'timeout');
+            return execute(combined, remaining);
+        }).catch((error) => { this.healthy = false; throw error; }).finally(() => {
+            combined.removeEventListener('abort', rejectWaiting);
+            clearTimeout(timer);
+            this.pendingOperations--;
+        });
+        this.operationTail = operation.then(() => { }, () => { });
+        if (combined.aborted)
+            rejectWaiting();
+        return Promise.race([operation, waitingCancelled]);
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieWFtYWhhLmNsYXNzZXMuY2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL3lhbWFoYS95YW1haGEuY2xhc3Nlcy5jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFeEQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRWxELE1BQU0sT0FBTyxZQUFhLFNBQVEsaUJBQWdDO0lBQ2hFLFlBQVksU0FBd0I7UUFDbEMsS0FBSyxDQUFDLGFBQWEsRUFBRSxTQUFTLENBQUMsQ0FBQztJQUNsQyxDQUFDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yamaha.classes.client.js","sourceRoot":"","sources":["../../../ts/integrations/yamaha/yamaha.classes.client.ts"],"names":[],"mappings":"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"}

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

@@ -1,5 +1,12 @@
-import { SimpleLocalConfigFlow } from '../../core/index.js';
+import { NativeIntegrationScope } from '../../core/classes.nativeintegrationowner.js';
+import type { IConfigFlow, INativeConfigFlowContext, IConfigFlowStep, IDiscoveryCandidate } from '../../core/types.js';
 import type { IYamahaConfig } from './yamaha.types.js';
-export declare class YamahaConfigFlow extends SimpleLocalConfigFlow<IYamahaConfig> {
-    constructor();
+export declare class YamahaConfigFlow implements IConfigFlow<IYamahaConfig> {
+    private readonly scope;
+    private readonly writes;
+    private closePromise?;
+    constructor(scope?: NativeIntegrationScope);
+    start(input: IDiscoveryCandidate, context: INativeConfigFlowContext): Promise<IConfigFlowStep<IYamahaConfig>>;
+    destroy(): Promise<void>;
+    retryCleanup(): Promise<void>;
 }

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