@smarthome.exchange/integrations 1.0.0 → 3.0.0

package/ts/integrations/braviatv/braviatv.classes.configflow.ts

@@ -1,84 +1,55 @@
 import type { IConfigFlow, IConfigFlowContext, IConfigFlowStep, IDiscoveryCandidate } from '../../core/types.js';
-import type { IBraviatvConfig } from './braviatv.types.js';
+import { NativeIntegrationOwner, type NativeIntegrationScope } from '../../core/classes.nativeintegrationowner.js';
+import type { IBraviatvConfig, IBraviatvIntegrationOptions } from './braviatv.types.js';
+import { BraviatvClient } from './braviatv.classes.client.js';
+import { braviatvRecord, normalizeBraviatvConfig, normalizeBraviatvOptions } from './braviatv.validation.js';
 
 export class BraviatvConfigFlow implements IConfigFlow<IBraviatvConfig> {
-  public async start(candidateArg: IDiscoveryCandidate, contextArg: IConfigFlowContext): Promise<IConfigFlowStep<IBraviatvConfig>> {
-    void contextArg;
-    return {
-      kind: 'form',
-      title: 'Connect Sony Bravia TV',
-      description: 'Configure the local Sony Bravia REST/IRCC endpoint. This native port supports PSK authentication for live control; PIN pairing/cookie auth is reported as unsupported.',
+  readonly #options?: Readonly<IBraviatvIntegrationOptions>;
+  readonly #scope: NativeIntegrationScope;
+  public constructor(options?: IBraviatvIntegrationOptions, scope?: NativeIntegrationScope) {
+    this.#options = options === undefined ? undefined : normalizeBraviatvOptions(options);
+    this.#scope = scope ?? new NativeIntegrationOwner('braviatv', { homeId: this.#options?.homeId, capacity: this.#options?.capacity }).createFlowScope();
+  }
+  public async start(input: IDiscoveryCandidate, context: IConfigFlowContext): Promise<IConfigFlowStep<IBraviatvConfig>> {
+    const candidate = braviatvRecord(input);
+    if (candidate.integrationDomain !== 'braviatv') return { kind: 'error', error: 'Candidate does not belong to BRAVIA.' };
+    if (!this.#options) return { kind: 'error', error: 'BRAVIA admission requires caller-owned PSK resolver options.' };
+    const options = this.#options;
+    const hints = { host: candidate.host };
+    const admitted = this.#scope.admit(context);
+    return { kind: 'form', title: 'Select BRAVIA Professional display',
+      description: 'Confirm private IPv4, model and active-network MAC for the host-selected home. Caller provides a private-level PSK reference. LAN HTTP is unencrypted and PSK access does not prove peer identity. Speaker volume uses integer raw levels.',
       fields: [
-        { name: 'host', label: 'Host', type: 'text', required: true },
-        { name: 'port', label: 'HTTP port', type: 'number' },
-        { name: 'useSsl', label: 'Use HTTPS', type: 'boolean' },
-        { name: 'psk', label: 'Pre-shared key (PSK)', type: 'password' },
-        { name: 'pin', label: 'PIN (pairing not implemented)', type: 'password' },
-        { name: 'name', label: 'Name', type: 'text' },
-        { name: 'model', label: 'Model', type: 'text' },
+        { name: 'host', label: 'Selected display IPv4', type: 'text', required: true },
+        { name: 'expectedModel', label: 'Exact observed model', type: 'text', required: true },
+        { name: 'expectedMacAddress', label: 'Exact active-network MAC', type: 'text', required: true },
+        { name: 'expectedSerial', label: 'Exact serial (optional)', type: 'text' },
+        { name: 'credentialRef', label: 'Caller private-level PSK reference', type: 'text', required: true },
+        { name: 'allowUnencryptedLan', label: 'Allow unencrypted selected LAN HTTP', type: 'boolean', required: true },
+        { name: 'volumeLimitRaw', label: 'Owner speaker ceiling (integer raw level 0..100)', type: 'number', required: true },
+        { name: 'name', label: 'Display name', type: 'text' },
       ],
-      submit: async (valuesArg) => {
-        const host = this.stringValue(valuesArg.host) || candidateArg.host;
-        if (!host) {
-          return { kind: 'error', error: 'Sony Bravia TV host is required.' };
-        }
-
-        const psk = this.stringValue(valuesArg.psk) || this.stringMetadata(candidateArg, 'psk');
-        const pin = this.stringValue(valuesArg.pin);
-        if (pin && !psk) {
-          return { kind: 'error', error: 'Sony Bravia TV PIN pairing/cookie authentication is not implemented in this native TypeScript port. Configure a PSK instead.' };
+      submit: async (inputValues) => {
+        try {
+          const values = braviatvRecord(inputValues, ['homeId', 'host', 'expectedModel', 'expectedMacAddress', 'expectedSerial',
+            'credentialRef', 'allowUnencryptedLan', 'volumeLimitRaw', 'name', 'port', 'timeoutMs', 'maxPendingOperations', 'maxResponseBytes']);
+          if (values.homeId !== undefined && values.homeId !== admitted.homeId) throw new Error('BRAVIA submitted home conflicts with the host-selected home.');
+          // Discovery supplies only captured endpoint hints; exact model and MAC remain explicit selections.
+          const config = normalizeBraviatvConfig({ ...values, homeId: admitted.homeId, host: values.host ?? hints.host });
+          return await this.#scope.run(admitted, config.homeId, async (lease) => {
+            const client = new BraviatvClient(config, { ...lease.context, abortSignal: lease.signal }, options);
+            lease.own(() => client.retryCleanup());
+            await client.start(lease.signal);
+            lease.assertOpen();
+            return { kind: 'done', title: 'Selected display admitted', config };
+          });
+        } catch (error) {
+          if (error instanceof AggregateError) throw error;
+          return { kind: 'error', title: 'Display admission failed', error: 'Confirm exact home and display identity, private PSK reference, explicit LAN consent, supported APIs and owner speaker ceiling.' };
         }
-
-        const useSsl = this.booleanValue(valuesArg.useSsl) ?? this.booleanMetadata(candidateArg, 'useSsl') ?? false;
-        return {
-          kind: 'done',
-          title: 'Sony Bravia TV configured',
-          config: {
-            host,
-            port: this.numberValue(valuesArg.port) || candidateArg.port || (useSsl ? 443 : 80),
-            useSsl,
-            psk,
-            pin,
-            usePsk: Boolean(psk),
-            name: this.stringValue(valuesArg.name) || candidateArg.name,
-            model: this.stringValue(valuesArg.model) || candidateArg.model,
-            manufacturer: candidateArg.manufacturer || 'Sony',
-            macAddress: candidateArg.macAddress,
-            serialNumber: candidateArg.serialNumber,
-            cid: candidateArg.id || this.stringMetadata(candidateArg, 'cid'),
-            scalarWebApiBaseUrl: this.stringMetadata(candidateArg, 'scalarWebApiBaseUrl'),
-          },
-        };
-      },
-    };
-  }
-
-  private stringValue(valueArg: unknown): string | undefined {
-    return typeof valueArg === 'string' && valueArg.trim() ? valueArg.trim() : undefined;
-  }
-
-  private numberValue(valueArg: unknown): number | undefined {
-    if (typeof valueArg === 'number' && Number.isFinite(valueArg)) {
-      return valueArg;
-    }
-    if (typeof valueArg === 'string' && valueArg.trim()) {
-      const value = Number(valueArg);
-      return Number.isFinite(value) ? value : undefined;
-    }
-    return undefined;
-  }
-
-  private booleanValue(valueArg: unknown): boolean | undefined {
-    return typeof valueArg === 'boolean' ? valueArg : undefined;
-  }
-
-  private stringMetadata(candidateArg: IDiscoveryCandidate, keyArg: string): string | undefined {
-    const value = candidateArg.metadata?.[keyArg];
-    return typeof value === 'string' && value ? value : undefined;
-  }
-
-  private booleanMetadata(candidateArg: IDiscoveryCandidate, keyArg: string): boolean | undefined {
-    const value = candidateArg.metadata?.[keyArg];
-    return typeof value === 'boolean' ? value : undefined;
+      } };
   }
+  public destroy(): Promise<void> { return this.#scope.close(); }
+  public retryCleanup(): Promise<void> { return this.#scope.retryCleanup(); }
 }

package/ts/integrations/braviatv/braviatv.classes.integration.ts

@@ -1,177 +1,197 @@
 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,
+  IServiceCallRequest, IServiceCallResult } from '../../core/types.js';
 import { BraviatvClient } from './braviatv.classes.client.js';
 import { BraviatvConfigFlow } from './braviatv.classes.configflow.js';
 import { createBraviatvDiscoveryDescriptor } from './braviatv.discovery.js';
 import { BraviatvMapper } from './braviatv.mapper.js';
-import type { IBraviatvConfig } from './braviatv.types.js';
+import { braviatvRecord, normalizeBraviatvConfig, normalizeBraviatvOptions, validateBraviatvControl } from './braviatv.validation.js';
+import type { IBraviatvConfig, IBraviatvEffectResult, IBraviatvIntegrationOptions,
+  IBraviatvSetupContext, IBraviatvSnapshot, TBraviatvControl } from './braviatv.types.js';
 
 export class BraviatvIntegration extends BaseIntegration<IBraviatvConfig> {
   public readonly domain = 'braviatv';
-  public readonly displayName = 'Sony Bravia TV';
+  public readonly displayName = 'Selected Sony BRAVIA Professional display';
   public readonly status = 'control-runtime' as const;
   public readonly discoveryDescriptor = createBraviatvDiscoveryDescriptor();
-  public readonly configFlow = new BraviatvConfigFlow();
-  public readonly metadata = {
-    source: 'home-assistant/core',
-    upstreamPath: 'homeassistant/components/braviatv',
-    upstreamDomain: 'braviatv',
-    integrationType: 'device',
-    iotClass: 'local_polling',
-    requirements: ['pybravia==0.4.1'],
-    dependencies: ['ssdp'],
-    afterDependencies: [],
-    codeowners: ['@bieniu', '@Drafteed'],
-    configFlow: true,
-    documentation: 'https://www.home-assistant.io/integrations/braviatv',
-  };
+  public readonly configFlow: BraviatvConfigFlow;
+  public readonly metadata = { source: 'native-typescript', integrationType: 'device', iotClass: 'local_poll',
+    documentation: 'https://pro-bravia.sony.net/remote-display-control/rest-api/reference/' };
+  readonly #options?: Readonly<IBraviatvIntegrationOptions>;
+  readonly #owner: NativeIntegrationOwner;
 
-  public async setup(configArg: IBraviatvConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime> {
-    void contextArg;
-    return new BraviatvRuntime(new BraviatvClient(configArg));
+  /** Unconfigured registry descriptors are inert; setup requires explicit caller home and credentials. */
+  public constructor(options?: IBraviatvIntegrationOptions) {
+    super();
+    this.#options = options === undefined ? undefined : normalizeBraviatvOptions(options);
+    this.#owner = new NativeIntegrationOwner('braviatv', { homeId: this.#options?.homeId, capacity: this.#options?.capacity });
+    this.configFlow = new BraviatvConfigFlow(this.#options, this.#owner.createFlowScope());
   }
 
-  public async destroy(): Promise<void> {}
-}
+  public setup(config: IBraviatvConfig, context: IBraviatvSetupContext): Promise<IIntegrationRuntime> {
+    if (!this.#options) return Promise.reject(new Error('BRAVIA setup requires caller-owned PSK resolver options.'));
+    const options = this.#options;
+    try {
+      const selected = normalizeBraviatvConfig(config);
+      return this.#owner.runSetup(context, selected.homeId, async (lease) => {
+        const client = new BraviatvClient(selected, { ...lease.context, abortSignal: lease.signal }, options);
+        let runtime: BraviatvRuntime | undefined;
+        lease.own(async () => {
+          const ownedRuntime = runtime;
+          const results = await Promise.allSettled([
+            Promise.resolve().then(() => client.retryCleanup()),
+            ...(ownedRuntime ? [Promise.resolve().then(() => ownedRuntime.closeSubscriptions())] : []),
+          ]);
+          const failures = results.filter((entry): entry is PromiseRejectedResult => entry.status === 'rejected');
+          if (failures.length) throw new AggregateError(failures.map((entry) => entry.reason), 'BRAVIA owned cleanup failed.');
+        });
+        const initial = await client.start(lease.signal);
+        lease.assertOpen();
+        runtime = new BraviatvRuntime(client, initial, lease);
+        lease.promoteToRuntime();
+        return runtime;
+      });
+    } catch (error) { return Promise.reject(error); }
+  }
 
+  public destroy(): Promise<void> {
+    return this.#owner.close();
+  }
+  public retryCleanup(): Promise<void> { return this.#owner.retryCleanup(); }
+}
 export class HomeAssistantBraviatvIntegration extends BraviatvIntegration {}
 
-class BraviatvRuntime implements IIntegrationRuntime {
-  public domain = 'braviatv';
+interface IBraviatvSubscription {
+  handler: (event: IIntegrationEvent) => void;
+  active: boolean;
+  failed: boolean;
+  detach(): void;
+  stop(): Promise<void>;
+}
 
-  constructor(private readonly client: BraviatvClient) {}
+class BraviatvRuntime implements IIntegrationRuntime {
+  public readonly domain = 'braviatv';
+  readonly #subscriptions = new Set<IBraviatvSubscription>();
+  readonly #parentAbort: () => void;
+  #closePromise?: Promise<void>;
+  #closed = false;
 
-  public async devices(): Promise<plugins.shxInterfaces.data.IDeviceDefinition[]> {
-    return BraviatvMapper.toDevices(await this.client.getSnapshot());
+  public constructor(private readonly client: BraviatvClient, private snapshot: IBraviatvSnapshot,
+    private readonly lease: INativeSetupLease) {
+    this.#parentAbort = () => { void this.destroy().catch(() => {}); };
+    lease.signal.addEventListener('abort', this.#parentAbort, { once: true });
+    if (lease.signal.aborted) this.#parentAbort();
+  }
+  public isHealthy(): boolean { return !this.#closed && this.client.isHealthy(); }
+  public async devices(signal?: AbortSignal): Promise<plugins.shxInterfaces.data.IDeviceDefinition[]> {
+    this.assertOpen();
+    const snapshot = await this.client.getSnapshot(signal);
+    this.publish(snapshot);
+    return BraviatvMapper.toDevices(snapshot);
   }
-
   public async entities(): Promise<IIntegrationEntity[]> {
-    return BraviatvMapper.toEntities(await this.client.getSnapshot());
+    this.assertOpen();
+    const snapshot = await this.client.getSnapshot();
+    this.publish(snapshot);
+    return BraviatvMapper.toEntities(snapshot);
   }
-
-  public async callService(requestArg: IServiceCallRequest): Promise<IServiceCallResult> {
-    try {
-      if (requestArg.domain === 'remote') {
-        return await this.callRemoteService(requestArg);
-      }
-      if (requestArg.domain === 'braviatv') {
-        return await this.callBraviatvService(requestArg);
-      }
-      if (requestArg.domain !== 'media_player') {
-        return { success: false, error: `Unsupported Sony Bravia TV service domain: ${requestArg.domain}` };
-      }
-      return await this.callMediaPlayerService(requestArg);
-    } catch (errorArg) {
-      return { success: false, error: errorArg instanceof Error ? errorArg.message : String(errorArg) };
-    }
+  public async writeFeature(input: IDeviceFeatureWriteRequest, signal?: AbortSignal): Promise<IServiceCallResult> {
+    this.assertOpen();
+    const request = braviatvRecord(input, ['device', 'feature', 'value']);
+    const device = braviatvRecord(request.device);
+    const feature = braviatvRecord(request.feature);
+    const deviceId = BraviatvMapper.deviceId(this.snapshot.homeId, this.snapshot.identity.macAddress);
+    if (device.id !== deviceId || device.integrationDomain !== this.domain) throw new Error('BRAVIA feature target is outside the selected home and display.');
+    const control = validateBraviatvControl({ feature: feature.id, value: request.value });
+    if (feature.capability !== (control.feature === 'speaker_volume_raw' ? 'sensor' : 'switch')) throw new Error('BRAVIA feature capability does not match the selected control.');
+    return this.control(control, signal);
   }
-
-  public async destroy(): Promise<void> {
-    await this.client.destroy();
+  public async callService(input: IServiceCallRequest): Promise<IServiceCallResult> {
+    this.assertOpen();
+    const request = braviatvRecord(input, ['domain', 'service', 'target', 'data']);
+    if (request.domain !== 'braviatv') throw new Error('BRAVIA selected-display services use braviatv.');
+    let control: TBraviatvControl;
+    if (request.service === 'set_power') {
+      const data = braviatvRecord(request.data, ['power']);
+      control = validateBraviatvControl({ feature: 'power', value: data.power });
+    } else if (request.service === 'set_device_mute') {
+      const data = braviatvRecord(request.data, ['muted']);
+      control = validateBraviatvControl({ feature: 'device_mute', value: data.muted });
+    } else if (request.service === 'set_speaker_volume_raw') {
+      const data = braviatvRecord(request.data, ['volume_raw']);
+      control = validateBraviatvControl({ feature: 'speaker_volume_raw', value: data.volume_raw });
+    } else throw new Error('BRAVIA supports separate absolute power, device mute and integer speaker volume services only.');
+    const target = braviatvRecord(request.target, ['deviceId', 'entityId']);
+    const deviceId = BraviatvMapper.deviceId(this.snapshot.homeId, this.snapshot.identity.macAddress);
+    const entityId = BraviatvMapper.entityId(this.snapshot.homeId, this.snapshot.identity.macAddress, control.feature);
+    if ((!target.deviceId && !target.entityId) || target.deviceId !== undefined && target.deviceId !== deviceId || target.entityId !== undefined && target.entityId !== entityId) {
+      throw new Error('BRAVIA service target is outside the selected home, display and control.');
+    }
+    return this.control(control);
   }
-
-  private async callRemoteService(requestArg: IServiceCallRequest): Promise<IServiceCallResult> {
-    if (requestArg.service !== 'send_command') {
-      return { success: false, error: `Unsupported Sony Bravia TV remote service: ${requestArg.service}` };
-    }
-    const command = requestArg.data?.command;
-    const commands = typeof command === 'string' ? [command] : Array.isArray(command) ? command.filter((itemArg): itemArg is string => typeof itemArg === 'string' && Boolean(itemArg)) : [];
-    if (!commands.length) {
-      return { success: false, error: 'Sony Bravia TV remote.send_command requires data.command.' };
-    }
-    const repeatsValue = requestArg.data?.num_repeats ?? requestArg.data?.numRepeats ?? 1;
-    const repeats = typeof repeatsValue === 'number' && Number.isFinite(repeatsValue) ? repeatsValue : 1;
-    await this.client.sendCommands(commands, repeats);
-    return { success: true };
+  /** Completed observations only; subscriptions never start a polling loop. */
+  public async subscribe(handler: (event: IIntegrationEvent) => void, signal?: AbortSignal): Promise<() => Promise<void>> {
+    this.assertOpen();
+    if (typeof handler !== 'function' || signal !== undefined && !(signal instanceof AbortSignal)) throw new TypeError('BRAVIA subscription requires a callback and optional AbortSignal.');
+    if (signal?.aborted) throw new Error('BRAVIA subscription was cancelled.');
+    if (this.#subscriptions.size >= 32) throw new Error('BRAVIA subscription capacity reached.');
+    const aborted = () => { subscription.detach(); this.#subscriptions.delete(subscription); };
+    const subscription: IBraviatvSubscription = { handler, active: true, failed: false,
+      detach: () => { subscription.active = false; signal?.removeEventListener('abort', aborted); },
+      stop: async () => { subscription.detach(); this.#subscriptions.delete(subscription);
+        if (subscription.failed) throw new Error('BRAVIA subscriber failed.'); } };
+    signal?.addEventListener('abort', aborted, { once: true });
+    this.#subscriptions.add(subscription);
+    if (signal?.aborted) aborted();
+    return subscription.stop;
   }
-
-  private async callBraviatvService(requestArg: IServiceCallRequest): Promise<IServiceCallResult> {
-    if (requestArg.service === 'reboot') {
-      await this.client.reboot();
-      return { success: true };
-    }
-    if (requestArg.service === 'terminate_apps') {
-      await this.client.terminateApps();
-      return { success: true };
-    }
-    return { success: false, error: `Unsupported Sony Bravia TV service: ${requestArg.service}` };
+  public destroy(): Promise<void> {
+    if (!this.#closePromise) {
+      this.#closePromise = Promise.resolve().then(() => this.lease.close());
+      this.#closed = true;
+      this.lease.signal.removeEventListener('abort', this.#parentAbort);
+      for (const subscription of this.#subscriptions) subscription.detach();
+    }
+    return this.#closePromise;
   }
-
-  private async callMediaPlayerService(requestArg: IServiceCallRequest): Promise<IServiceCallResult> {
-    if (requestArg.service === 'turn_on') {
-      await this.client.turnOn();
-      return { success: true };
-    }
-    if (requestArg.service === 'turn_off') {
-      await this.client.turnOff();
-      return { success: true };
-    }
-    if (requestArg.service === 'play' || requestArg.service === 'media_play') {
-      await this.client.mediaPlay();
-      return { success: true };
-    }
-    if (requestArg.service === 'pause' || requestArg.service === 'media_pause') {
-      await this.client.mediaPause();
-      return { success: true };
-    }
-    if (requestArg.service === 'play_pause' || requestArg.service === 'media_play_pause') {
-      await this.client.sendCommand('Play');
-      return { success: true };
-    }
-    if (requestArg.service === 'stop' || requestArg.service === 'media_stop') {
-      await this.client.mediaStop();
-      return { success: true };
-    }
-    if (requestArg.service === 'next_track' || requestArg.service === 'media_next_track') {
-      await this.client.nextTrack();
-      return { success: true };
-    }
-    if (requestArg.service === 'previous_track' || requestArg.service === 'media_previous_track') {
-      await this.client.previousTrack();
-      return { success: true };
-    }
-    if (requestArg.service === 'volume_set') {
-      const level = requestArg.data?.volume_level;
-      if (typeof level !== 'number') {
-        return { success: false, error: 'Sony Bravia TV volume_set requires data.volume_level.' };
-      }
-      await this.client.setVolumeLevel(level);
-      return { success: true };
-    }
-    if (requestArg.service === 'volume_up') {
-      await this.client.volumeUp();
-      return { success: true };
-    }
-    if (requestArg.service === 'volume_down') {
-      await this.client.volumeDown();
-      return { success: true };
-    }
-    if (requestArg.service === 'volume_mute' || requestArg.service === 'mute') {
-      const muted = requestArg.data?.is_volume_muted ?? requestArg.data?.muted;
-      if (typeof muted !== 'boolean') {
-        return { success: false, error: 'Sony Bravia TV volume_mute requires data.is_volume_muted.' };
-      }
-      await this.client.muteVolume(muted);
-      return { success: true };
-    }
-    if (requestArg.service === 'select_source') {
-      const source = requestArg.data?.source;
-      if (typeof source !== 'string' || !source) {
-        return { success: false, error: 'Sony Bravia TV select_source requires data.source.' };
-      }
-      await this.client.selectSource(source);
-      return { success: true };
+  public async closeSubscriptions(): Promise<void> {
+    this.#closed = true;
+    this.lease.signal.removeEventListener('abort', this.#parentAbort);
+    const results = await Promise.allSettled([...this.#subscriptions].map((entry) => entry.stop()));
+    const failures = results.filter((entry): entry is PromiseRejectedResult => entry.status === 'rejected');
+    if (failures.length) throw new AggregateError(failures.map((entry) => entry.reason), 'BRAVIA subscriber cleanup failed.');
+  }
+  private async control(control: TBraviatvControl, signal?: AbortSignal): Promise<IServiceCallResult> {
+    try {
+      const result = await this.client.setControl(control, signal);
+      this.publish(result.snapshot);
+      return this.result(result);
+    } catch (error) {
+      const failure = error instanceof plugins.ecobridgeDeviceManager.SonyBraviaProtocolError ? error : undefined;
+      return { success: false, error: failure?.message ?? 'BRAVIA selected-display control was not admitted.',
+        data: { effectOutcome: failure?.effectOutcome ?? 'not-sent', commandAcknowledged: failure?.commandAcknowledged ?? false, causalityConfirmed: false,
+          ...(failure ? { code: failure.code } : {}) } };
     }
-    if (requestArg.service === 'play_media') {
-      const mediaId = requestArg.data?.media_content_id;
-      const mediaType = requestArg.data?.media_content_type;
-      if (typeof mediaId !== 'string' || typeof mediaType !== 'string') {
-        return { success: false, error: 'Sony Bravia TV play_media requires data.media_content_type and data.media_content_id.' };
-      }
-      await this.client.playMedia(mediaType, mediaId);
-      return { success: true };
+  }
+  private result(result: IBraviatvEffectResult): IServiceCallResult {
+    return { success: result.observation === 'matching-reported-state',
+      ...(result.observation === 'different-reported-state' ? { error: 'BRAVIA acknowledged the command, but the independent reported state differs.' } : {}),
+      data: { commandAcknowledged: result.commandAcknowledged, causalityConfirmed: result.causalityConfirmed,
+        observation: result.observation, control: result.control, requested: result.requested,
+        devices: BraviatvMapper.toDevices(result.snapshot), entities: BraviatvMapper.toEntities(result.snapshot) } };
+  }
+  private publish(snapshot: IBraviatvSnapshot): void {
+    if (this.#closed) return;
+    this.snapshot = snapshot;
+    for (const subscription of [...this.#subscriptions]) {
+      if (this.#closed) break;
+      if (!subscription.active) continue;
+      try { subscription.handler({ type: 'state_changed', integrationDomain: this.domain,
+        deviceId: BraviatvMapper.deviceId(snapshot.homeId, snapshot.identity.macAddress), data: structuredClone(snapshot), timestamp: Date.now() }); }
+      catch { subscription.failed = true; subscription.detach(); }
     }
-    return { success: false, error: `Unsupported Sony Bravia TV media_player service: ${requestArg.service}` };
   }
+  private assertOpen(): void { if (this.#closed) throw new Error('BRAVIA runtime is closed.'); }
 }

package/ts/integrations/braviatv/braviatv.discovery.ts

@@ -30,8 +30,8 @@ export class BraviatvSsdpMatcher implements IDiscoveryMatcher<IBraviatvSsdpRecor
     const id = stripUuid(usn || stringValue(recordArg, 'udn', 'UDN')) || stringValue(recordArg, 'cid', 'macAddr');
     return {
       matched: true,
-      confidence: id ? 'certain' : 'high',
-      reason: 'SSDP record matches Sony Bravia ScalarWebAPI metadata.',
+      confidence: 'medium',
+      reason: 'Unverified SSDP metadata supplies Sony BRAVIA setup hints only.',
       normalizedDeviceId: id,
       candidate: {
         source: 'ssdp',
@@ -72,8 +72,8 @@ export class BraviatvMdnsMatcher implements IDiscoveryMatcher<IBraviatvMdnsRecor
     const id = valueForKey(properties, 'cid') || valueForKey(properties, 'id') || valueForKey(properties, 'deviceid') || name;
     return {
       matched: true,
-      confidence: id ? 'certain' : recordArg.host ? 'high' : 'medium',
-      reason: 'mDNS record matches Sony Bravia metadata.',
+      confidence: 'medium',
+      reason: 'Unverified mDNS metadata supplies Sony BRAVIA setup hints only.',
       normalizedDeviceId: id,
       candidate: {
         source: 'mdns',
@@ -88,7 +88,6 @@ export class BraviatvMdnsMatcher implements IDiscoveryMatcher<IBraviatvMdnsRecor
         metadata: {
           mdnsType: recordArg.type,
           mdnsName: recordArg.name,
-          txt: properties,
         },
       },
     };
@@ -116,17 +115,14 @@ export class BraviatvManualMatcher implements IDiscoveryMatcher<IBraviatvManualE
         integrationDomain: 'braviatv',
         id,
         host: inputArg.host,
-        port: inputArg.port || (inputArg.useSsl ? 443 : 80),
+        port: inputArg.port || 80,
         name: inputArg.name,
         manufacturer: inputArg.manufacturer || 'Sony',
         model: inputArg.model,
         serialNumber: inputArg.serialNumber,
         macAddress: inputArg.macAddress,
         metadata: {
-          ...(inputArg.metadata || {}),
           cid: inputArg.cid,
-          psk: inputArg.psk,
-          useSsl: inputArg.useSsl,
         },
       },
     };
@@ -146,7 +142,12 @@ export class BraviatvCandidateValidator implements IDiscoveryValidator {
       matched,
       confidence: matched && candidateArg.host ? 'high' : matched ? 'medium' : 'low',
       reason: matched ? 'Candidate has Sony Bravia metadata.' : 'Candidate is not Sony Bravia TV.',
-      candidate: matched ? candidateArg : undefined,
+      candidate: matched ? {
+        source: candidateArg.source, integrationDomain: 'braviatv', id: candidateArg.id,
+        host: candidateArg.host, port: candidateArg.port, name: candidateArg.name,
+        manufacturer: candidateArg.manufacturer, model: candidateArg.model,
+        macAddress: candidateArg.macAddress, serialNumber: candidateArg.serialNumber,
+      } : undefined,
       normalizedDeviceId: candidateArg.id || candidateArg.macAddress || candidateArg.serialNumber || candidateArg.host,
     };
   }