@smarthome.exchange/integrations 0.2.0 → 1.0.0

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

@@ -1,15 +1,160 @@
-import { SimpleLocalIntegration } from '../../core/index.js';
+import * as plugins from '../../plugins.js';
+import { BaseIntegration } from '../../core/classes.baseintegration.js';
+import { LifxClient } from './lifx.classes.client.js';
 import { LifxConfigFlow } from './lifx.classes.configflow.js';
 import { createLifxDiscoveryDescriptor } from './lifx.discovery.js';
-import { lifxDomain, lifxProfile } from './lifx.types.js';
-export class LifxIntegration extends SimpleLocalIntegration {
-    domain = lifxDomain;
+import { LifxMapper } from './lifx.mapper.js';
+import { lifxProfile } from './lifx.types.js';
+import { assertLifxStoreScope, lifxInteger, lifxKeys, lifxRecord, normalizeLifxConfig, readLifxColor } from './lifx.validation.js';
+export class LifxIntegration extends BaseIntegration {
+    domain = 'lifx';
+    displayName = 'LIFX';
+    status = 'control-runtime';
+    metadata = lifxProfile.metadata;
     discoveryDescriptor = createLifxDiscoveryDescriptor();
     configFlow = new LifxConfigFlow();
-    constructor() {
-        super(lifxProfile);
+    #runtimes = new Set();
+    #pending = new Set();
+    #setups = new Set();
+    #closed = false;
+    #closePromise;
+    setup(configArg, contextArg) {
+        if (this.#closed)
+            return Promise.reject(new Error('LIFX integration is destroyed.'));
+        const setup = this.#createRuntime(configArg, contextArg).finally(() => this.#setups.delete(setup));
+        this.#setups.add(setup);
+        return setup;
+    }
+    async #createRuntime(configArg, contextArg) {
+        const config = normalizeLifxConfig(configArg);
+        assertLifxStoreScope(contextArg.configStore, config.homeId);
+        const client = new LifxClient(config, contextArg.abortSignal);
+        this.#pending.add(client);
+        try {
+            const snapshot = await client.getSnapshot(contextArg.abortSignal);
+            if (this.#closed || contextArg.abortSignal?.aborted)
+                throw new Error('LIFX setup was canceled.');
+            const runtime = new LifxRuntime(client, snapshot, () => this.#runtimes.delete(runtime));
+            this.#runtimes.add(runtime);
+            return runtime;
+        }
+        catch (errorArg) {
+            await client.destroy();
+            throw errorArg;
+        }
+        finally {
+            this.#pending.delete(client);
+        }
+    }
+    destroy() {
+        if (this.#closePromise)
+            return this.#closePromise;
+        this.#closed = true;
+        this.#closePromise = Promise.resolve().then(async () => {
+            await Promise.all([
+                ...[...this.#runtimes].map((runtimeArg) => runtimeArg.destroy()),
+                ...[...this.#pending].map((clientArg) => clientArg.destroy()),
+            ]);
+            await Promise.allSettled([...this.#setups]);
+        });
+        return this.#closePromise;
     }
 }
 export class HomeAssistantLifxIntegration extends LifxIntegration {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlmeC5jbGFzc2VzLmludGVncmF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL2xpZngvbGlmeC5jbGFzc2VzLmludGVncmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQzdELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUM5RCxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVwRSxPQUFPLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRTFELE1BQU0sT0FBTyxlQUFnQixTQUFRLHNCQUFtQztJQUN0RCxNQUFNLEdBQUcsVUFBVSxDQUFDO0lBQ3BCLG1CQUFtQixHQUFHLDZCQUE2QixFQUFFLENBQUM7SUFDdEQsVUFBVSxHQUFHLElBQUksY0FBYyxFQUFFLENBQUM7SUFFbEQ7UUFDRSxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDckIsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLDRCQUE2QixTQUFRLGVBQWU7Q0FBRyJ9
+class LifxRuntime {
+    client;
+    released;
+    domain = 'lifx';
+    #deviceId;
+    #entityId;
+    #hasLight;
+    #closePromise;
+    constructor(client, identityArg, released) {
+        this.client = client;
+        this.released = released;
+        this.#deviceId = LifxMapper.deviceId(identityArg);
+        this.#entityId = LifxMapper.lightEntityId(identityArg);
+        this.#hasLight = identityArg.lightState !== undefined;
+    }
+    isHealthy() { return this.client.isHealthy(); }
+    async devices(signalArg) {
+        return LifxMapper.toDevices(await this.client.getSnapshot(signalArg));
+    }
+    async entities() { return LifxMapper.toEntities(await this.client.getSnapshot()); }
+    async callService(requestArg) {
+        try {
+            const request = lifxRecord(requestArg, 'service request');
+            lifxKeys(request, ['domain', 'service', 'target', 'data']);
+            if (typeof request.domain !== 'string' || typeof request.service !== 'string')
+                throw new TypeError('LIFX service domain and service must be strings.');
+            this.#assertTarget(request.target);
+            const data = request.data === undefined ? {} : lifxRecord(request.data, 'service data');
+            if (request.domain === 'lifx' && ['status', 'snapshot', 'refresh'].includes(request.service)) {
+                lifxKeys(data, []);
+                return { success: true, data: await this.client.getSnapshot() };
+            }
+            if (request.domain === 'light' && ['turn_on', 'turn_off'].includes(request.service)) {
+                lifxKeys(data, ['durationMs']);
+                const duration = lifxInteger(data.durationMs === undefined ? 0 : data.durationMs, 0, 60000, 'durationMs');
+                return accepted(await this.client.setPower(request.service === 'turn_on', duration));
+            }
+            if (request.domain === 'lifx' && request.service === 'set_hsbk') {
+                lifxKeys(data, ['hue', 'saturation', 'brightness', 'kelvin', 'durationMs']);
+                const color = readLifxColor({ hue: data.hue, saturation: data.saturation, brightness: data.brightness, kelvin: data.kelvin });
+                const duration = lifxInteger(data.durationMs === undefined ? 0 : data.durationMs, 0, 60000, 'durationMs');
+                return accepted(await this.client.setHsbk(color, duration));
+            }
+            throw new TypeError('LIFX service is unsupported.');
+        }
+        catch (errorArg) {
+            return failed(errorArg);
+        }
+    }
+    async writeFeature(requestArg, signalArg) {
+        try {
+            const request = lifxRecord(requestArg, 'feature write');
+            lifxKeys(request, ['device', 'feature', 'value']);
+            const device = lifxRecord(request.device, 'feature device');
+            const feature = lifxRecord(request.feature, 'feature');
+            if (device.id !== this.#deviceId || device.integrationDomain !== this.domain)
+                throw new TypeError('LIFX feature device is not owned by this home runtime.');
+            if (feature.id === 'power') {
+                if (typeof request.value !== 'boolean')
+                    throw new TypeError('LIFX power feature requires a boolean.');
+                return accepted(await this.client.setPower(request.value, 0, signalArg));
+            }
+            if (feature.id === 'hsbk')
+                return accepted(await this.client.setHsbk(readLifxColor(request.value), 0, signalArg));
+            throw new TypeError('LIFX feature is not writable.');
+        }
+        catch (errorArg) {
+            return failed(errorArg);
+        }
+    }
+    destroy() {
+        this.#closePromise ??= this.client.destroy().then(() => { this.released(); });
+        return this.#closePromise;
+    }
+    #assertTarget(valueArg) {
+        const target = lifxRecord(valueArg, 'service target');
+        lifxKeys(target, ['deviceId', 'entityId']);
+        if (target.deviceId === undefined && target.entityId === undefined ||
+            target.deviceId !== undefined && target.deviceId !== this.#deviceId ||
+            target.entityId !== undefined && (target.entityId !== this.#entityId || !this.#hasLight)) {
+            throw new TypeError('LIFX services require one exact owned device or light entity target.');
+        }
+    }
+}
+function accepted(resultArg) {
+    return { success: true, data: { effectOutcome: resultArg.outcome, observedState: { ...resultArg.observedState }, physicalCompletion: 'unconfirmed' } };
+}
+function failed(errorArg) {
+    return {
+        success: false,
+        error: errorArg instanceof Error ? errorArg.message : 'LIFX operation failed.',
+        data: { effectOutcome: errorArg instanceof plugins.ecobridgeDeviceManager.LifxProtocolError ? errorArg.effectOutcome : 'not-sent',
+            code: errorArg instanceof plugins.ecobridgeDeviceManager.LifxProtocolError ? errorArg.code : 'INVALID_OPERATION' },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lifx.classes.integration.js","sourceRoot":"","sources":["../../../ts/integrations/lifx/lifx.classes.integration.ts"],"names":[],"mappings":"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"}

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

@@ -1 +1,2 @@
-export declare const createLifxDiscoveryDescriptor: () => import("../../core/classes.discoverydescriptor.js").DiscoveryDescriptor;
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+export declare function createLifxDiscoveryDescriptor(): DiscoveryDescriptor;

package/dist_ts/integrations/lifx/lifx.discovery.js

@@ -1,4 +1,26 @@
-import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
-import { lifxProfile } from './lifx.types.js';
-export const createLifxDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(lifxProfile);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlmeC5kaXNjb3ZlcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvbGlmeC9saWZ4LmRpc2NvdmVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0NBQW9DLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUMzRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFOUMsTUFBTSxDQUFDLE1BQU0sNkJBQTZCLEdBQUcsR0FBRyxFQUFFLENBQUMsb0NBQW9DLENBQUMsV0FBVyxDQUFDLENBQUMifQ==
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import { lifxName, lifxRecord, readLifxEndpoint } from './lifx.validation.js';
+function matchCandidate(valueArg) {
+    try {
+        const input = lifxRecord(valueArg, 'discovery candidate');
+        if (input.source !== 'manual' && input.source !== 'custom' || input.integrationDomain !== 'lifx') {
+            return { matched: false, confidence: 'low', reason: 'An explicit manual/custom LIFX candidate is required.' };
+        }
+        const endpoint = readLifxEndpoint(input.host, input.macAddress, input.port);
+        const candidate = {
+            source: input.source === 'manual' ? 'manual' : 'custom', integrationDomain: 'lifx', ...endpoint,
+            name: input.name === undefined ? undefined : lifxName(input.name, 'candidate name'),
+        };
+        return { matched: true, confidence: 'medium', reason: 'Explicit LIFX endpoint/MAC binding; live identity is checked during setup.', candidate };
+    }
+    catch (errorArg) {
+        return { matched: false, confidence: 'low', reason: errorArg instanceof Error ? errorArg.message : 'Invalid LIFX endpoint candidate.' };
+    }
+}
+export function createLifxDiscoveryDescriptor() {
+    return new DiscoveryDescriptor({ integrationDomain: 'lifx', displayName: 'LIFX' })
+        .addMatcher({ id: 'lifx-manual-match', source: 'manual', matches: async (inputArg) => matchCandidate(inputArg) })
+        .addMatcher({ id: 'lifx-custom-match', source: 'custom', matches: async (inputArg) => matchCandidate(inputArg) })
+        .addValidator({ id: 'lifx-explicit-endpoint', validate: async (candidateArg) => matchCandidate(candidateArg) });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/lifx/lifx.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 { ILifxConfig } from './lifx.types.js';
+import type * as plugins from '../../plugins.js';
+import type { IIntegrationEntity } from '../../core/types.js';
+import type { ILifxSnapshot } from './lifx.types.js';
 export declare class LifxMapper {
-    static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<ILifxConfig>, 'profile'>): ISimpleLocalSnapshot;
-    static toSnapshotFromRaw(configArg: ILifxConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot;
-    static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[];
-    static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[];
-    static slug(valueArg: unknown): string;
+    static deviceId(snapshotArg: Pick<ILifxSnapshot, 'homeId' | 'deviceInfo'>): string;
+    static lightEntityId(snapshotArg: Pick<ILifxSnapshot, 'homeId' | 'deviceInfo'>): string;
+    static toDevices(snapshotArg: ILifxSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[];
+    static toEntities(snapshotArg: ILifxSnapshot): IIntegrationEntity[];
 }

package/dist_ts/integrations/lifx/lifx.mapper.js

@@ -1,20 +1,50 @@
-import { SimpleLocalMapper } from '../../core/index.js';
-import { lifxProfile } from './lifx.types.js';
 export class LifxMapper {
-    static toSnapshot(optionsArg) {
-        return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: lifxProfile });
+    static deviceId(snapshotArg) {
+        return `lifx:${encodeURIComponent(snapshotArg.homeId)}:${snapshotArg.deviceInfo.macAddress}`;
     }
-    static toSnapshotFromRaw(configArg, rawDataArg) {
-        return SimpleLocalMapper.toSnapshot({ profile: lifxProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+    static lightEntityId(snapshotArg) {
+        return `${this.deviceId(snapshotArg)}:light`;
     }
     static toDevices(snapshotArg) {
-        return SimpleLocalMapper.toDevices(lifxProfile, snapshotArg);
+        const info = snapshotArg.deviceInfo;
+        const light = snapshotArg.lightState;
+        const features = [
+            { id: 'connectivity', capability: 'sensor', name: 'Connectivity', readable: true, writable: false },
+            { id: 'product', capability: 'sensor', name: 'Product', readable: true, writable: false },
+            { id: 'firmware', capability: 'sensor', name: 'Firmware', readable: true, writable: false },
+        ];
+        const state = [
+            { featureId: 'connectivity', value: 'online', updatedAt: snapshotArg.observedAt },
+            { featureId: 'product', value: info.product, updatedAt: snapshotArg.observedAt },
+            { featureId: 'firmware', value: `${info.firmware.major}.${info.firmware.minor}`, updatedAt: snapshotArg.observedAt },
+        ];
+        if (light) {
+            const singleZone = info.capabilities?.layout === 'single-zone' && info.capabilities.temperatureRange !== undefined;
+            features.push({ id: 'power', capability: 'light', name: 'Power', readable: true, writable: singleZone });
+            state.push({ featureId: 'power', value: light.power > 0, updatedAt: snapshotArg.observedAt });
+            features.push({ id: 'hsbk', capability: 'light', name: 'HSBK (exact uint16 units)', readable: true, writable: singleZone && info.capabilities?.color === true });
+            state.push({ featureId: 'hsbk', value: { hue: light.hue, saturation: light.saturation, brightness: light.brightness, kelvin: light.kelvin }, updatedAt: snapshotArg.observedAt });
+        }
+        return [{
+                id: this.deviceId(snapshotArg), integrationDomain: 'lifx', name: snapshotArg.name,
+                manufacturer: info.vendor === 1 ? 'LIFX' : undefined,
+                model: info.capabilities?.name, protocol: 'udp', online: snapshotArg.online,
+                features, state,
+                metadata: { homeId: snapshotArg.homeId, macAddress: info.macAddress, vendor: info.vendor, product: info.product,
+                    firmwareBuild: info.firmware.build, capabilities: info.capabilities, lanAuthenticated: false },
+            }];
     }
     static toEntities(snapshotArg) {
-        return SimpleLocalMapper.toEntities(lifxProfile, snapshotArg);
-    }
-    static slug(valueArg) {
-        return SimpleLocalMapper.slug(valueArg);
+        const light = snapshotArg.lightState;
+        if (!light)
+            return [];
+        return [{
+                id: this.lightEntityId(snapshotArg), uniqueId: this.lightEntityId(snapshotArg), deviceId: this.deviceId(snapshotArg),
+                integrationDomain: 'lifx', platform: 'light', name: snapshotArg.name, state: light.power > 0 ? 'on' : 'off',
+                available: snapshotArg.online,
+                attributes: { hue: light.hue, saturation: light.saturation, brightness: light.brightness, kelvin: light.kelvin,
+                    rawPower: light.power, observedAt: snapshotArg.observedAt, capabilities: snapshotArg.deviceInfo.capabilities },
+            }];
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlmeC5tYXBwZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvbGlmeC9saWZ4Lm1hcHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsaUJBQWlCLEVBQWtILE1BQU0scUJBQXFCLENBQUM7QUFFeEssT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRTlDLE1BQU0sT0FBTyxVQUFVO0lBQ2QsTUFBTSxDQUFDLFVBQVUsQ0FBQyxVQUFxRTtRQUM1RixPQUFPLGlCQUFpQixDQUFDLFVBQVUsQ0FBQyxFQUFFLEdBQUcsVUFBVSxFQUFFLE9BQU8sRUFBRSxXQUFXLEVBQUUsQ0FBQyxDQUFDO0lBQy9FLENBQUM7SUFFTSxNQUFNLENBQUMsaUJBQWlCLENBQUMsU0FBc0IsRUFBRSxVQUErQjtRQUNyRixPQUFPLGlCQUFpQixDQUFDLFVBQVUsQ0FBQyxFQUFFLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDeEksQ0FBQztJQUVNLE1BQU0sQ0FBQyxTQUFTLENBQUMsV0FBaUM7UUFDdkQsT0FBTyxpQkFBaUIsQ0FBQyxTQUFTLENBQUMsV0FBVyxFQUFFLFdBQVcsQ0FBQyxDQUFDO0lBQy9ELENBQUM7SUFFTSxNQUFNLENBQUMsVUFBVSxDQUFDLFdBQWlDO1FBQ3hELE9BQU8saUJBQWlCLENBQUMsVUFBVSxDQUFDLFdBQVcsRUFBRSxXQUFXLENBQUMsQ0FBQztJQUNoRSxDQUFDO0lBRU0sTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFpQjtRQUNsQyxPQUFPLGlCQUFpQixDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUMxQyxDQUFDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,14 +1,66 @@
-import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
 export declare const lifxDomain = "lifx";
 export declare const lifxDefaultName = "LIFX";
-export type TLifxRawData = TSimpleLocalRawData;
-export interface ILifxSnapshot extends ISimpleLocalSnapshot {
-}
-export interface ILifxConfig extends ISimpleLocalConfig {
-    url?: string;
-    macAddress?: string;
-    deviceId?: string;
+export interface ILifxConfig {
+    homeId: string;
+    host: string;
+    macAddress: string;
+    /** Endpoint/MAC binding does not authenticate the LAN peer cryptographically. */
+    allowUnencryptedLan: true;
+    port?: number;
+    name?: string;
+    requestTimeoutMs?: number;
+    maxPendingOperations?: number;
 }
 export interface IHomeAssistantLifxConfig extends ILifxConfig {
 }
-export declare const lifxProfile: ISimpleLocalIntegrationProfile;
+export interface ILifxColor {
+    hue: number;
+    saturation: number;
+    brightness: number;
+    kelvin: number;
+}
+export interface ILifxLightState extends ILifxColor {
+    power: number;
+    label: string;
+}
+export interface ILifxDeviceIdentity {
+    macAddress: string;
+    vendor: number;
+    product: number;
+    firmware: {
+        build: string;
+        major: number;
+        minor: number;
+    };
+    capabilities?: {
+        name: string;
+        color: boolean;
+        layout: 'single-zone' | 'linear' | 'matrix' | 'chain' | 'relay' | 'unsupported';
+        temperatureRange?: readonly [number, number];
+    };
+}
+/** JSON-safe observations, never an injectable production data source. */
+export interface ILifxSnapshot {
+    homeId: string;
+    name: string;
+    deviceInfo: ILifxDeviceIdentity;
+    lightState?: ILifxLightState;
+    observedAt: string;
+    online: true;
+}
+export type TLifxRawData = ILifxSnapshot;
+export declare const lifxProfile: {
+    readonly domain: "lifx";
+    readonly displayName: "LIFX";
+    readonly status: 'control-runtime';
+    readonly metadata: {
+        readonly source: 'home-assistant/core';
+        readonly upstreamDomain: "lifx";
+        readonly configFlow: true;
+        readonly localApi: {
+            readonly status: 'Native explicit-unicast LIFX LAN UDP binary protocol through devicemanager.';
+            readonly implemented: readonly ['home-scoped device identity', 'firmware-derived single-zone capability admission', 'power and full exact-wire HSBK control', 'one-shot acceptance and independent state observation'];
+            readonly explicitUnsupported: readonly ['broadcast discovery', 'cloud access', 'injected clients and snapshots', 'partial HSBK patches', 'white-product HSBK writes', 'multizone/matrix/chain/relay control', 'effects/themes/HEV/infrared', 'toggle and automatic effect retries', 'cryptographic LAN peer authentication'];
+        };
+    };
+};

package/dist_ts/integrations/lifx/lifx.types.js

@@ -1,121 +1,14 @@
-export const lifxDomain = "lifx";
-export const lifxDefaultName = "LIFX";
+export const lifxDomain = 'lifx';
+export const lifxDefaultName = 'LIFX';
 export const lifxProfile = {
-    domain: lifxDomain,
-    displayName: "LIFX",
-    manufacturer: "LIFX",
-    model: "LIFX local integration",
-    defaultName: lifxDefaultName,
-    defaultProtocol: 'local',
-    status: "control-runtime",
-    platforms: [
-        "binary_sensor",
-        "button",
-        "light",
-        "select",
-        "sensor",
-    ],
-    serviceDomains: [
-        "button",
-        "light",
-        "select",
-    ],
-    controlServices: [
-        "effect_colorloop",
-        "effect_flame",
-        "effect_morph",
-        "effect_move",
-        "effect_pulse",
-        "effect_sky",
-        "effect_stop",
-        "paint_theme",
-        "press",
-        "select_option",
-        "set_hev_cycle_state",
-        "set_state",
-        "toggle",
-        "turn_off",
-        "turn_on",
-    ],
-    discoverySources: [
-        'manual',
-        'custom',
-    ],
-    discoveryKeywords: [
-        "lifx",
-        "LIFX",
-        "Lifx",
-    ],
+    domain: lifxDomain, displayName: lifxDefaultName, status: 'control-runtime',
     metadata: {
-        "source": "home-assistant/core",
-        "upstreamPath": "homeassistant/components/lifx",
-        "upstreamDomain": "lifx",
-        "integrationType": "device",
-        "iotClass": "local_polling",
-        "requirements": [
-            "aiolifx==1.2.1",
-            "aiolifx-effects==0.3.2",
-            "aiolifx-themes==1.0.2",
-        ],
-        "dependencies": [
-            "network",
-        ],
-        "codeowners": [
-            "@Djelibeybi",
-        ],
-        "configFlow": true,
-        "documentation": "https://www.home-assistant.io/integrations/lifx",
-        "loggers": [
-            "aiolifx",
-            "aiolifx_effects",
-            "bitstring",
-        ],
-        "runtime": {
-            "type": "control-runtime",
-            "services": [
-                "snapshot",
-                "status",
-                "refresh",
-                "effect_colorloop",
-                "effect_flame",
-                "effect_morph",
-                "effect_move",
-                "effect_pulse",
-                "effect_sky",
-                "effect_stop",
-                "paint_theme",
-                "press",
-                "select_option",
-                "set_hev_cycle_state",
-                "set_state",
-                "toggle",
-                "turn_off",
-                "turn_on",
-            ],
-            "platforms": [
-                "binary_sensor",
-                "button",
-                "light",
-                "select",
-                "sensor",
-            ],
-            "controls": "delegated only to an injected client.execute or commandExecutor; native live LIFX LAN control is blocked by the aiolifx UDP binary protocol/effects stack",
-        },
-        "localApi": {
-            "status": "snapshot/injected-client only: Home Assistant uses aiolifx over the LIFX LAN UDP binary protocol on port 56700 plus aiolifx-effects/aiolifx-themes; no HTTP/TCP/TLS/file protocol is available to implement with the allowed runtime helpers",
-            "implemented": [
-                "manual local setup for LIFX snapshots, rawData, snapshotProvider, and injected native clients",
-                "runtime mapping for LIFX device snapshots and Home Assistant platform metadata",
-                "safe command delegation to injected client.execute or commandExecutor only",
-            ],
-            "explicitUnsupported": [
-                "native live LIFX LAN polling/control: requires aiolifx UDP binary protocol implementation and effect/theme libraries, not an HTTP/TCP/TLS/file protocol available through existing helpers",
-                "LIFX UDP broadcast discovery and HomeKit/DHCP confirmation flows that depend on aiolifx LIFXConnection",
-                "claiming live LIFX polling, pairing, subscription, or write success without an injected native client or snapshotProvider",
-                "Home Assistant entity registry migrations and repair flows",
-                "claiming command success without injected client.execute or commandExecutor",
-            ],
+        source: 'home-assistant/core', upstreamDomain: lifxDomain, configFlow: true,
+        localApi: {
+            status: 'Native explicit-unicast LIFX LAN UDP binary protocol through devicemanager.',
+            implemented: ['home-scoped device identity', 'firmware-derived single-zone capability admission', 'power and full exact-wire HSBK control', 'one-shot acceptance and independent state observation'],
+            explicitUnsupported: ['broadcast discovery', 'cloud access', 'injected clients and snapshots', 'partial HSBK patches', 'white-product HSBK writes', 'multizone/matrix/chain/relay control', 'effects/themes/HEV/infrared', 'toggle and automatic effect retries', 'cryptographic LAN peer authentication'],
         },
     },
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlmeC50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy9saWZ4L2xpZngudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLE1BQU0sQ0FBQztBQUNqQyxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsTUFBTSxDQUFDO0FBOEN0QyxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUc7SUFDekIsTUFBTSxFQUFFLFVBQVUsRUFBRSxXQUFXLEVBQUUsZUFBZSxFQUFFLE1BQU0sRUFBRSxpQkFBaUI7SUFDM0UsUUFBUSxFQUFFO1FBQ1IsTUFBTSxFQUFFLHFCQUFxQixFQUFFLGNBQWMsRUFBRSxVQUFVLEVBQUUsVUFBVSxFQUFFLElBQUk7UUFDM0UsUUFBUSxFQUFFO1lBQ1IsTUFBTSxFQUFFLDZFQUE2RTtZQUNyRixXQUFXLEVBQUUsQ0FBQyw2QkFBNkIsRUFBRSxtREFBbUQsRUFBRSx3Q0FBd0MsRUFBRSx1REFBdUQsQ0FBQztZQUNwTSxtQkFBbUIsRUFBRSxDQUFDLHFCQUFxQixFQUFFLGNBQWMsRUFBRSxnQ0FBZ0MsRUFBRSxzQkFBc0IsRUFBRSwyQkFBMkIsRUFBRSxzQ0FBc0MsRUFBRSw2QkFBNkIsRUFBRSxxQ0FBcUMsRUFBRSx1Q0FBdUMsQ0FBQztTQUMzUztLQUNGO0NBQ08sQ0FBQyJ9

package/dist_ts/integrations/lifx/lifx.validation.d.ts

@@ -0,0 +1,10 @@
+import type { IConfigStore } from '../../core/types.js';
+import type { ILifxColor, ILifxConfig } from './lifx.types.js';
+export declare function lifxRecord(valueArg: unknown, nameArg: string): Record<string, unknown>;
+export declare function lifxKeys(recordArg: Record<string, unknown>, keysArg: readonly string[]): void;
+export declare function lifxInteger(valueArg: unknown, minimumArg: number, maximumArg: number, nameArg: string): number;
+export declare function lifxName(valueArg: unknown, nameArg: string, maximumArg?: number): string;
+export declare function readLifxEndpoint(hostArg: unknown, macArg: unknown, portArg?: unknown): Pick<ILifxConfig, 'host' | 'macAddress' | 'port'>;
+export declare function normalizeLifxConfig(valueArg: unknown): Readonly<ILifxConfig>;
+export declare function assertLifxStoreScope(storeArg: IConfigStore | undefined, homeIdArg: string): void;
+export declare function readLifxColor(valueArg: unknown): ILifxColor;