@smarthome.exchange/integrations 0.2.0 → 2.0.0

package/ts/integrations/daikin/daikin.classes.configflow.ts

@@ -1,168 +1,88 @@
-import * as plugins from '../../plugins.js';
 import type { IConfigFlow, IConfigFlowContext, IConfigFlowStep, IDiscoveryCandidate } from '../../core/types.js';
-import type { IDaikinConfig, IDaikinRawData, IDaikinSnapshot, IDaikinValueMap, TDaikinApiVariant } from './daikin.types.js';
-import { daikinDefaultHttpPort, daikinDefaultHttpsPort, daikinDefaultTimeoutMs, daikinSkyFiPort } from './daikin.types.js';
+import { NativeIntegrationOwner, type NativeIntegrationScope } from '../../core/classes.nativeintegrationowner.js';
+import { DaikinClient } from './daikin.classes.client.js';
+import type { IDaikinIntegrationOptions, IDaikinNativeConfig } from './daikin.types.js';
+import { daikinKeys, daikinObject, normalizeDaikinConfig } from './daikin.validation.js';
 
-export class DaikinConfigFlow implements IConfigFlow<IDaikinConfig> {
-  public async start(candidateArg: IDiscoveryCandidate, contextArg: IConfigFlowContext): Promise<IConfigFlowStep<IDaikinConfig>> {
-    void contextArg;
+export class DaikinConfigFlow implements IConfigFlow<IDaikinNativeConfig> {
+  readonly #scope: NativeIntegrationScope;
+
+  constructor(optionsArg: IDaikinIntegrationOptions = {}, scopeArg?: NativeIntegrationScope) {
+    this.#scope = scopeArg ?? new NativeIntegrationOwner('daikin', optionsArg).createFlowScope();
+  }
+
+  public destroy(): Promise<void> { return this.#scope.close(); }
+  public retryCleanup(): Promise<void> { return this.#scope.retryCleanup(); }
+
+  public async start(candidateArg: IDiscoveryCandidate, contextArg: IConfigFlowContext): Promise<IConfigFlowStep<IDaikinNativeConfig>> {
+    const context = this.#scope.admit(contextArg);
+    const candidate = daikinObject(candidateArg, 'Daikin candidate');
+    const metadata = candidate.metadata === undefined ? {} : daikinObject(candidate.metadata, 'Daikin candidate metadata');
+    const host = typeof candidate.host === 'string' ? candidate.host : undefined;
+    const expectedMac = typeof candidate.macAddress === 'string' ? candidate.macAddress.replace(/:/g, '') : typeof metadata.expectedMac === 'string' ? metadata.expectedMac : undefined;
     return {
-      kind: 'form',
-      title: 'Configure Daikin AC',
-      description: 'Configure a local Daikin endpoint, or use snapshot/manual data from the discovery candidate. Use either API key or SkyFi password, not both.',
+      kind: 'form', title: 'Connect selected Daikin BRP069',
+      description: 'Select a private IPv4 address and exact 12-digit adapter MAC for the host-selected home. Setup verifies basic, model and current control observations. BRP069 LAN HTTP is unauthenticated. No credentials are accepted.',
       fields: [
-        { name: 'host', label: 'Host', type: 'text' },
-        { name: 'port', label: 'Port', type: 'number' },
-        { name: 'apiVariant', label: 'API variant', type: 'select', options: [
-          { label: 'Auto / BRP069 local HTTP', value: 'auto' },
-          { label: 'BRP069 local HTTP', value: 'brp069' },
-          { label: 'BRP072C HTTPS with API key', value: 'brp072c' },
-          { label: 'AirBase / skyfi path prefix', value: 'airbase' },
-          { label: 'SkyFi password API', value: 'skyfi' },
-          { label: 'BRP084 dsiot read-only', value: 'brp084' },
-        ] },
-        { name: 'ssl', label: 'Use HTTPS', type: 'boolean' },
-        { name: 'verifySsl', label: 'Verify TLS certificate', type: 'boolean' },
-        { name: 'apiKey', label: 'API key', type: 'password' },
-        { name: 'uuid', label: 'Terminal UUID', type: 'text' },
-        { name: 'password', label: 'SkyFi password', type: 'password' },
+        { name: 'host', label: 'Selected private IPv4', type: 'text', required: true },
+        { name: 'expectedMac', label: 'Exact adapter MAC (12 hex digits)', type: 'text', required: true },
+        { name: 'apiVariant', label: 'Controller family', type: 'select', required: true, options: [{ label: 'Selected BRP069', value: 'brp069' }] },
+        { name: 'allowPlaintext', label: 'Allow unauthenticated plaintext LAN HTTP', type: 'boolean', required: true },
+        { name: 'port', label: 'HTTP port (80)', type: 'number' },
         { name: 'name', label: 'Name', type: 'text' },
       ],
-      submit: async (valuesArg) => this.submit(candidateArg, valuesArg),
+      submit: async (valuesArg) => {
+        let config: Readonly<IDaikinNativeConfig>;
+        try {
+          const values = daikinObject(valuesArg, 'Daikin configuration form');
+          daikinKeys(values, ['homeId', 'host', 'expectedMac', 'apiVariant', 'allowPlaintext', 'port', 'name']);
+          if (values.homeId !== undefined && values.homeId !== context.homeId) throw new TypeError('Daikin submitted home must match the independently selected host home.');
+          config = normalizeDaikinConfig({
+            homeId: context.homeId,
+            host: formText(values.host, host),
+            expectedMac: formText(values.expectedMac, expectedMac),
+            apiVariant: selectedVariant(values.apiVariant), allowPlaintext: selectedPlaintext(values.allowPlaintext), port: formPort(values.port, candidate.port),
+            name: values.name === undefined ? undefined : formText(values.name),
+          });
+          this.#scope.admit(context, config.homeId);
+        } catch (errorArg) {
+          return { kind: 'error', title: 'Daikin verification failed', error: errorArg instanceof Error ? errorArg.message : 'Daikin configuration is invalid.' };
+        }
+        return this.#scope.run(context, config.homeId, async (leaseArg): Promise<IConfigFlowStep<IDaikinNativeConfig>> => {
+          const client = new DaikinClient(config, leaseArg.context);
+          leaseArg.own(() => client.destroy());
+          try {
+            await client.getSnapshot(leaseArg.signal);
+            leaseArg.assertOpen();
+            return { kind: 'done', title: 'Verified selected Daikin BRP069', config };
+          } catch (errorArg) {
+            return { kind: 'error', title: 'Daikin verification failed', error: errorArg instanceof Error ? errorArg.message : 'Daikin verification failed.' };
+          }
+        });
+      },
     };
   }
-
-  private async submit(candidateArg: IDiscoveryCandidate, valuesArg: Record<string, unknown>): Promise<IConfigFlowStep<IDaikinConfig>> {
-    const metadata = candidateArg.metadata || {};
-    const parsed = parseEndpoint(this.stringValue(valuesArg.host) || this.stringValue(metadata.url));
-    const snapshot = snapshotValue(metadata.snapshot);
-    const rawData = rawDataValue(metadata.rawData);
-    const apiKey = this.stringValue(valuesArg.apiKey) || this.stringMetadata(metadata, 'apiKey');
-    const password = this.stringValue(valuesArg.password) || this.stringMetadata(metadata, 'password');
-    const apiVariant = this.apiVariant(this.stringValue(valuesArg.apiVariant) || this.stringMetadata(metadata, 'apiVariant'), apiKey, password);
-    const host = parsed?.host || this.stringValue(valuesArg.host) || candidateArg.host || snapshot?.device.host;
-    const ssl = this.booleanValue(valuesArg.ssl) ?? this.booleanMetadata(metadata, 'ssl') ?? parsed?.ssl ?? snapshot?.device.ssl ?? apiVariant === 'brp072c';
-    const port = this.numberValue(valuesArg.port) || candidateArg.port || parsed?.port || snapshot?.device.port || this.defaultPort(apiVariant, ssl);
-    const hasManualData = Boolean(snapshot || rawData || metadata.values || metadata.client);
-
-    if (apiKey && password) {
-      return { kind: 'error', title: 'Daikin setup failed', error: 'Invalid authentication: use either API key or password, not both.' };
-    }
-    if (!host && !hasManualData) {
-      return { kind: 'error', title: 'Daikin setup failed', error: 'Daikin host, injected client, snapshot, or manual data is required.' };
-    }
-    if (!this.validPort(port)) {
-      return { kind: 'error', title: 'Daikin setup failed', error: 'Daikin port must be between 1 and 65535.' };
-    }
-
-    const config: IDaikinConfig = {
-      host,
-      port,
-      ssl,
-      verifySsl: this.booleanValue(valuesArg.verifySsl) ?? this.booleanMetadata(metadata, 'verifySsl') ?? false,
-      apiKey,
-      uuid: this.stringValue(valuesArg.uuid) || this.stringMetadata(metadata, 'uuid') || (apiKey ? plugins.crypto.randomUUID().replace(/-/g, '') : undefined),
-      password,
-      apiVariant,
-      timeoutMs: daikinDefaultTimeoutMs,
-      name: this.stringValue(valuesArg.name) || candidateArg.name || snapshot?.device.name || this.stringMetadata(metadata, 'name'),
-      manufacturer: candidateArg.manufacturer || snapshot?.device.manufacturer || 'Daikin',
-      model: candidateArg.model || snapshot?.device.model,
-      uniqueId: candidateArg.id || snapshot?.device.id || snapshot?.device.macAddress || (host ? `${host}:${port}` : undefined),
-      macAddress: candidateArg.macAddress || snapshot?.device.macAddress,
-      snapshot,
-      rawData,
-      values: valueMapValue(metadata.values),
-      client: metadata.client as IDaikinConfig['client'],
-      commandExecutor: metadata.commandExecutor as IDaikinConfig['commandExecutor'],
-    };
-
-    return { kind: 'done', title: 'Daikin configured', config };
-  }
-
-  private apiVariant(valueArg: string | undefined, apiKeyArg: string | undefined, passwordArg: string | undefined): TDaikinApiVariant {
-    if (passwordArg) {
-      return 'skyfi';
-    }
-    if (apiKeyArg) {
-      return 'brp072c';
-    }
-    const allowed: TDaikinApiVariant[] = ['auto', 'brp069', 'brp072c', 'airbase', 'skyfi', 'brp084'];
-    return allowed.includes(valueArg as TDaikinApiVariant) ? valueArg as TDaikinApiVariant : 'auto';
-  }
-
-  private defaultPort(apiVariantArg: TDaikinApiVariant, sslArg: boolean): number {
-    if (apiVariantArg === 'skyfi') {
-      return daikinSkyFiPort;
-    }
-    return sslArg ? daikinDefaultHttpsPort : daikinDefaultHttpPort;
-  }
-
-  private stringValue(valueArg: unknown): string | undefined {
-    return typeof valueArg === 'string' && valueArg.trim() ? valueArg.trim().replace(/\/$/, '') : undefined;
-  }
-
-  private numberValue(valueArg: unknown): number | undefined {
-    if (typeof valueArg === 'number' && Number.isFinite(valueArg)) {
-      return Math.round(valueArg);
-    }
-    if (typeof valueArg === 'string' && valueArg.trim()) {
-      const parsed = Number(valueArg);
-      return Number.isFinite(parsed) ? Math.round(parsed) : undefined;
-    }
-    return undefined;
-  }
-
-  private booleanValue(valueArg: unknown): boolean | undefined {
-    if (typeof valueArg === 'boolean') {
-      return valueArg;
-    }
-    if (typeof valueArg === 'string') {
-      const normalized = valueArg.trim().toLowerCase();
-      if (['true', 'yes', 'on', '1'].includes(normalized)) {
-        return true;
-      }
-      if (['false', 'no', 'off', '0'].includes(normalized)) {
-        return false;
-      }
-    }
-    return undefined;
-  }
-
-  private stringMetadata(metadataArg: Record<string, unknown>, keyArg: string): string | undefined {
-    return this.stringValue(metadataArg[keyArg]);
-  }
-
-  private booleanMetadata(metadataArg: Record<string, unknown>, keyArg: string): boolean | undefined {
-    const value = metadataArg[keyArg];
-    return typeof value === 'boolean' ? value : undefined;
-  }
-
-  private validPort(valueArg: number): boolean {
-    return Number.isInteger(valueArg) && valueArg > 0 && valueArg <= 65535;
-  }
 }
 
-const parseEndpoint = (valueArg: string | undefined): { host: string; port?: number; ssl: boolean } | undefined => {
-  if (!valueArg || !/^[a-z][a-z0-9+.-]*:\/\//i.test(valueArg)) {
-    return undefined;
-  }
-  try {
-    const url = new URL(valueArg);
-    return { host: url.hostname, port: url.port ? Number(url.port) : undefined, ssl: url.protocol === 'https:' };
-  } catch {
-    return undefined;
-  }
+const selectedVariant = (valueArg: unknown): 'brp069' => {
+  if (valueArg !== 'brp069') throw new TypeError('Select the BRP069 controller family explicitly.');
+  return valueArg;
 };
-
-const snapshotValue = (valueArg: unknown): IDaikinSnapshot | undefined => {
-  return valueArg && typeof valueArg === 'object' && 'device' in valueArg && 'climate' in valueArg ? valueArg as IDaikinSnapshot : undefined;
+const formPort = (valueArg: unknown, hintArg: unknown): number | undefined => {
+  const value = valueArg === undefined || valueArg === '' ? hintArg : valueArg;
+  if (value === undefined) return undefined;
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string' && /^\d{1,5}$/.test(value)) return Number(value);
+  throw new TypeError('Daikin port must be an integer.');
 };
 
-const rawDataValue = (valueArg: unknown): Partial<IDaikinRawData> | undefined => {
-  return valueArg && typeof valueArg === 'object' && !Array.isArray(valueArg) ? valueArg as Partial<IDaikinRawData> : undefined;
+const selectedPlaintext = (valueArg: unknown): true => {
+  if (valueArg !== true) throw new TypeError('Explicitly allow unauthenticated plaintext LAN HTTP.');
+  return valueArg;
 };
 
-const valueMapValue = (valueArg: unknown): IDaikinValueMap | undefined => {
-  return valueArg && typeof valueArg === 'object' && !Array.isArray(valueArg) ? valueArg as IDaikinValueMap : undefined;
+const formText = (valueArg: unknown, hintArg?: string): string => {
+  if (valueArg === undefined) return hintArg ?? '';
+  if (typeof valueArg !== 'string') throw new TypeError('Daikin text fields must be strings.');
+  return valueArg;
 };

package/ts/integrations/daikin/daikin.classes.integration.ts

@@ -1,107 +1,202 @@
-import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import * as plugins from '../../plugins.js';
 import { BaseIntegration } from '../../core/classes.baseintegration.js';
-import type { IIntegrationEntity, IIntegrationRuntime, IIntegrationSetupContext, IServiceCallRequest, IServiceCallResult } from '../../core/types.js';
+import { NativeIntegrationOwner, type INativeSetupLease } from '../../core/classes.nativeintegrationowner.js';
+import type { IDeviceFeatureWriteRequest, IIntegrationEntity, IIntegrationEvent, IIntegrationRuntime, IIntegrationSetupContext, ILogger, IServiceCallRequest, IServiceCallResult } from '../../core/types.js';
 import { DaikinClient } from './daikin.classes.client.js';
 import { DaikinConfigFlow } from './daikin.classes.configflow.js';
 import { createDaikinDiscoveryDescriptor } from './daikin.discovery.js';
 import { DaikinMapper } from './daikin.mapper.js';
-import type { IDaikinConfig } from './daikin.types.js';
-import { daikinDisplayName, daikinDomain } from './daikin.types.js';
+import type { IDaikinIntegrationOptions, IDaikinNativeConfig, IDaikinSnapshot } from './daikin.types.js';
+import { normalizeDaikinConfig } from './daikin.validation.js';
 
-export class DaikinIntegration extends BaseIntegration<IDaikinConfig> {
-  public readonly domain = daikinDomain;
-  public readonly displayName = daikinDisplayName;
+const failure = (errorArg: unknown): IServiceCallResult => ({
+  success: false, error: errorArg instanceof Error ? errorArg.message : 'Daikin operation failed.',
+  data: errorArg instanceof plugins.ecobridgeDeviceManager.DaikinProtocolError
+    ? { code: errorArg.code, effectOutcome: errorArg.effectOutcome }
+    : { effectOutcome: 'not-sent' },
+});
+
+export class DaikinIntegration extends BaseIntegration<IDaikinNativeConfig> {
+  public readonly domain = 'daikin';
+  public readonly displayName = 'Daikin BRP069';
   public readonly status = 'control-runtime' as const;
   public readonly discoveryDescriptor = createDaikinDiscoveryDescriptor();
-  public readonly configFlow = new DaikinConfigFlow();
+  public readonly configFlow: DaikinConfigFlow;
   public readonly metadata = {
-    source: 'home-assistant/core',
-    upstreamPath: 'homeassistant/components/daikin',
-    upstreamDomain: daikinDomain,
-    integrationType: 'device',
-    iotClass: 'local_polling',
-    requirements: ['pydaikin==2.17.2'],
-    dependencies: [] as string[],
-    afterDependencies: [] as string[],
-    codeowners: ['@fredrike'],
-    configFlow: true,
-    documentation: 'https://www.home-assistant.io/integrations/daikin',
-    zeroconf: ['_dkapi._tcp.local.'],
-    discovery: {
-      zeroconf: '_dkapi._tcp.local.',
-      udp: 'DAIKIN_UDP/common/basic_info broadcast on UDP 30050 from source port 30000.',
-      http: 'Manual HTTP candidates for /common/basic_info, /aircon/*, /skyfi/*, and /dsiot/* are recognized.',
-      manual: true,
-    },
-    runtime: {
-      type: 'control-runtime',
-      polling: 'local Daikin HTTP key/value APIs plus SkyFi and BRP084 dsiot read modeling',
-      services: ['snapshot', 'status', 'refresh', 'climate controls', 'power switch', 'zone switch', 'streamer', 'holiday/advanced modes when represented by local endpoints'],
-      controls: true,
-    },
+    source: '@ecobridge.xyz/devicemanager', upstreamDomain: 'daikin', integrationType: 'device', iotClass: 'local_polling',
     localApi: {
-      implemented: [
-        'BRP069-style key/value local HTTP reads and set_control_info writes',
-        'BRP072C register_terminal/API-key request modeling when HTTPS is usable by the runtime',
-        'AirBase skyfi-prefixed reads plus zone setting writes',
-        'SkyFi password API reads and set.cgi/setzone.cgi writes',
-        'BRP084 dsiot snapshot reads',
-        'snapshot/manual-data and injected client/executor operation',
-      ],
-      explicitUnsupported: [
-        'BRP084 dsiot control writes without an injected commandExecutor',
-        'faking command success for snapshot/manual-only configurations',
-        'forcing TLS certificate bypass for BRP072C self-signed devices through Node fetch',
-      ],
+      implemented: ['selected BRP069 fresh identity/model/control observations', 'explicit power', 'integer target in observed cool or heat mode', 'independent readback'],
+      explicitUnsupported: ['automatic family selection', 'mode/humidity/fan/direction changes', 'other controller-family effects', 'cloud', 'retries', 'optimistic state', 'injected effect executors'],
     },
   };
+  readonly #owner: NativeIntegrationOwner;
+
+  constructor(optionsArg: IDaikinIntegrationOptions = {}) {
+    super();
+    this.#owner = new NativeIntegrationOwner(this.domain, optionsArg);
+    this.configFlow = new DaikinConfigFlow({}, this.#owner.createFlowScope());
+  }
 
-  public async setup(configArg: IDaikinConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime> {
-    void contextArg;
-    return new DaikinRuntime(new DaikinClient(configArg));
+  public async setup(configArg: IDaikinNativeConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime> {
+    const config = normalizeDaikinConfig(configArg);
+    return this.#owner.runSetup(contextArg, config.homeId, async (leaseArg) => {
+      const client = new DaikinClient(config, leaseArg.context);
+      let runtime: DaikinRuntime | undefined;
+      leaseArg.own(() => runtime ? runtime.cleanupOwnedResource() : client.destroy());
+      const identity = await client.getSnapshot(leaseArg.signal);
+      leaseArg.assertOpen();
+      runtime = new DaikinRuntime(client, identity, leaseArg, leaseArg.context.logger);
+      leaseArg.promoteToRuntime();
+      return runtime;
+    });
   }
 
-  public async destroy(): Promise<void> {}
+  public destroy(): Promise<void> { return this.#owner.close(); }
+  public retryCleanup(): Promise<void> { return this.#owner.retryCleanup(); }
 }
 
 export class HomeAssistantDaikinIntegration extends DaikinIntegration {}
 
+interface IDaikinSubscriber {
+  handler: (eventArg: IIntegrationEvent) => void;
+  cleanup: () => void;
+}
+
 class DaikinRuntime implements IIntegrationRuntime {
-  public domain = daikinDomain;
+  public readonly domain = 'daikin';
+  readonly #identity: IDaikinSnapshot;
+  readonly #subscriptions = new Set<IDaikinSubscriber>();
+  #entities: IIntegrationEntity[];
+  #available = true;
+  #destroy?: Promise<void>;
+  #removeAbort: () => void = () => undefined;
 
-  constructor(private readonly client: DaikinClient) {}
+  constructor(private readonly client: DaikinClient, identityArg: IDaikinSnapshot, private readonly lease: INativeSetupLease,
+    private readonly logger?: ILogger) {
+    this.#identity = structuredClone(identityArg);
+    this.#entities = DaikinMapper.toEntities(identityArg);
+    // The lease retains failed cleanup; destroy() and the owner expose its stable rejection.
+    const aborted = (): void => { void this.destroy().catch(() => undefined); };
+    lease.signal.addEventListener('abort', aborted, { once: true });
+    this.#removeAbort = () => lease.signal.removeEventListener('abort', aborted);
+    if (lease.signal.aborted) aborted();
+  }
 
-  public async devices(): Promise<shxInterfaces.data.IDeviceDefinition[]> {
-    return DaikinMapper.toDevices(await this.client.getSnapshot());
+  public isHealthy(): boolean { return !this.#destroy && this.client.isHealthy(); }
+  public async devices(signalArg?: AbortSignal): Promise<plugins.shxInterfaces.data.IDeviceDefinition[]> {
+    return DaikinMapper.toDevices(await this.#snapshot(signalArg));
   }
+  public async entities(): Promise<IIntegrationEntity[]> { return DaikinMapper.toEntities(await this.#snapshot()); }
 
-  public async entities(): Promise<IIntegrationEntity[]> {
-    return DaikinMapper.toEntities(await this.client.getSnapshot());
+  public async subscribe(handlerArg: (eventArg: IIntegrationEvent) => void, signalArg?: AbortSignal): Promise<() => Promise<void>> {
+    this.#assertOpen();
+    if (typeof handlerArg !== 'function') throw new TypeError('Daikin subscriber must be a function.');
+    if (signalArg !== undefined && !(signalArg instanceof AbortSignal)) throw new TypeError('Daikin subscriber signal must be an AbortSignal.');
+    signalArg?.throwIfAborted();
+    if (this.#subscriptions.size >= 128) throw new Error('Daikin subscriber capacity is exhausted.');
+    const subscriber: IDaikinSubscriber = { handler: handlerArg, cleanup: () => {
+      this.#subscriptions.delete(subscriber);
+      signalArg?.removeEventListener('abort', subscriber.cleanup);
+    } };
+    this.#subscriptions.add(subscriber);
+    signalArg?.addEventListener('abort', subscriber.cleanup, { once: true });
+    if (signalArg?.aborted) subscriber.cleanup();
+    return async () => subscriber.cleanup();
   }
 
   public async callService(requestArg: IServiceCallRequest): Promise<IServiceCallResult> {
     try {
-      if (requestArg.domain === daikinDomain && (requestArg.service === 'snapshot' || requestArg.service === 'status')) {
-        return { success: true, data: await this.client.getSnapshot() };
-      }
-      if (requestArg.domain === daikinDomain && requestArg.service === 'refresh') {
-        const result = await this.client.refresh();
-        return { success: result.success, error: result.error, data: result.snapshot || result.data };
+      this.#assertOpen();
+      const control = DaikinMapper.controlForService(this.#identity, requestArg);
+      if (control === 'snapshot') {
+        const snapshot = await this.client.getSnapshot();
+        this.#observe(snapshot);
+        return { success: true, data: snapshot };
       }
+      return this.#result(await this.client.setControl(control));
+    } catch (errorArg) { this.#report(errorArg); return failure(errorArg); }
+  }
+
+  public async writeFeature(requestArg: IDeviceFeatureWriteRequest, signalArg?: AbortSignal): Promise<IServiceCallResult> {
+    try {
+      this.#assertOpen();
+      return this.#result(await this.client.setControl(DaikinMapper.controlForFeature(this.#identity, requestArg), signalArg));
+    } catch (errorArg) { this.#report(errorArg); return failure(errorArg); }
+  }
+
+  public destroy(): Promise<void> {
+    this.#destroy ??= Promise.resolve().then(() => this.lease.close());
+    return this.#destroy;
+  }
 
-      const snapshot = await this.client.getSnapshot();
-      const command = DaikinMapper.commandForService(snapshot, requestArg);
-      if (!command) {
-        return { success: false, error: `Unsupported Daikin service: ${requestArg.domain}.${requestArg.service}` };
+  /** One adapter resource groups its client and subscriptions; every sibling must settle. */
+  public async cleanupOwnedResource(): Promise<void> {
+    const results = await Promise.allSettled([
+      Promise.resolve().then(() => this.#removeAbort()),
+      ...[...this.#subscriptions].map((subscriberArg) => Promise.resolve().then(() => subscriberArg.cleanup())),
+      Promise.resolve().then(() => this.client.destroy()),
+    ]);
+    const errors = results.filter((resultArg): resultArg is PromiseRejectedResult => resultArg.status === 'rejected').map((resultArg) => resultArg.reason as unknown);
+    if (errors.length) throw new AggregateError(errors, 'Daikin runtime resource cleanup failed.');
+  }
+
+  async #snapshot(signalArg?: AbortSignal): Promise<IDaikinSnapshot> {
+    this.#assertOpen();
+    try {
+      const snapshot = await this.client.getSnapshot(signalArg);
+      this.#observe(snapshot);
+      return snapshot;
+    } catch (errorArg) { this.#report(errorArg); throw errorArg; }
+  }
+
+  #result(dataArg: plugins.ecobridgeDeviceManager.IDaikinControlResult): IServiceCallResult {
+    this.#observe(DaikinMapper.fromState(this.client.config, dataArg.observed));
+    return { success: dataArg.effectOutcome === 'confirmed', data: dataArg,
+      error: dataArg.effectOutcome === 'confirmed' ? undefined : 'Daikin setter was accepted but requested state was not confirmed by observation.' };
+  }
+
+  #observe(snapshotArg: IDaikinSnapshot): void {
+    const entities = DaikinMapper.toEntities(snapshotArg);
+    if (!this.#available) this.#emit({ type: 'availability_changed', data: { available: true } });
+    this.#available = true;
+    for (const entity of entities) {
+      const previous = this.#entities.find((entryArg) => entryArg.id === entity.id);
+      if (!previous || JSON.stringify([previous.state, previous.attributes]) !== JSON.stringify([entity.state, entity.attributes])) {
+        this.#emit({ type: 'state_changed', entityId: entity.id, data: entity });
       }
-      const data = await this.client.execute(command);
-      return { success: true, data: data ?? command };
-    } catch (errorArg) {
-      return { success: false, error: errorArg instanceof Error ? errorArg.message : String(errorArg) };
     }
+    this.#entities = entities;
+  }
+
+  #report(errorArg: unknown): void {
+    if (!this.client.isHealthy() && this.#available) {
+      this.#available = false;
+      this.#emit({ type: 'availability_changed', data: { available: false } });
+    }
+    this.#emit({ type: 'error', data: failure(errorArg) });
+  }
+
+  #emit(eventArg: Pick<IIntegrationEvent, 'type' | 'data'> & { entityId?: string }): void {
+    if (this.#destroy) return;
+    const event: IIntegrationEvent = { ...eventArg, integrationDomain: this.domain,
+      deviceId: DaikinMapper.deviceId(this.#identity), timestamp: Date.now() };
+    for (const subscriber of [...this.#subscriptions]) {
+      if (!this.#subscriptions.has(subscriber)) continue;
+      try {
+        const returned: unknown = subscriber.handler(structuredClone(event));
+        if (returned instanceof Promise) void returned.catch(() => this.#subscriberFailed(subscriber));
+      } catch { this.#subscriberFailed(subscriber); }
+    }
+  }
+
+  #subscriberFailed(subscriberArg: IDaikinSubscriber): void {
+    subscriberArg.cleanup();
+    this.logger?.log('error', 'Daikin event subscriber failed.');
+    this.#emit({ type: 'error', data: { error: 'Daikin event subscriber failed.' } });
   }
 
-  public async destroy(): Promise<void> {
-    await this.client.destroy();
+  #assertOpen(): void {
+    if (this.#destroy) throw new Error('Daikin runtime is destroyed.');
+    this.lease.assertOpen();
   }
 }