@smarthome.exchange/integrations 0.2.0 → 2.0.0

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

@@ -1,8 +1,96 @@
-import { SimpleLocalClient } from '../../core/index.js';
-import { lifxProfile } from './lifx.types.js';
-export class LifxClient extends SimpleLocalClient {
-    constructor(configArg) {
-        super(lifxProfile, configArg);
+import * as plugins from '../../plugins.js';
+import { normalizeLifxConfig, readLifxColor } from './lifx.validation.js';
+export class LifxClient {
+    #config;
+    #protocol;
+    #lifetime = new AbortController();
+    #operations = new Set();
+    #parentSignal;
+    #onParentAbort;
+    #healthy = false;
+    #closed = false;
+    #closePromise;
+    constructor(configArg, signalArg) {
+        this.#config = normalizeLifxConfig(configArg);
+        if (signalArg !== undefined && !(signalArg instanceof AbortSignal))
+            throw new TypeError('LIFX lifetime signal must be an AbortSignal.');
+        this.#protocol = new plugins.ecobridgeDeviceManager.LifxProtocol({
+            host: this.#config.host, macAddress: this.#config.macAddress, port: this.#config.port,
+            timeoutMs: this.#config.requestTimeoutMs, maxPendingOperations: this.#config.maxPendingOperations,
+        });
+        this.#parentSignal = signalArg;
+        this.#onParentAbort = () => { void this.destroy(); };
+        signalArg?.addEventListener('abort', this.#onParentAbort, { once: true });
+        if (signalArg?.aborted)
+            this.#onParentAbort();
+    }
+    isHealthy() { return this.#healthy && !this.#closed; }
+    getSnapshot(signalArg) {
+        return this.#run(async (signal) => {
+            const info = await this.#protocol.getDeviceInfo({ signal });
+            const light = info.capabilities?.layout === 'single-zone' && info.capabilities.temperatureRange ?
+                await this.#protocol.getLightState({ signal }) : undefined;
+            const capabilities = info.capabilities && {
+                ...info.capabilities,
+                temperatureRange: info.capabilities.temperatureRange && [info.capabilities.temperatureRange[0], info.capabilities.temperatureRange[1]],
+            };
+            signal.throwIfAborted();
+            return {
+                homeId: this.#config.homeId,
+                name: this.#config.name ?? (light?.label || capabilities?.name || `LIFX ${info.macAddress}`),
+                deviceInfo: { macAddress: info.macAddress, vendor: info.vendor, product: info.product,
+                    firmware: { build: info.firmware.build.toString(), major: info.firmware.major, minor: info.firmware.minor }, capabilities },
+                lightState: light && { ...light }, online: true, observedAt: new Date().toISOString(),
+            };
+        }, signalArg);
+    }
+    setPower(onArg, durationMsArg = 0, signalArg) {
+        return this.#run((signal) => this.#protocol.setPower(onArg, { durationMs: durationMsArg, signal }), signalArg);
+    }
+    setHsbk(colorArg, durationMsArg = 0, signalArg) {
+        const color = readLifxColor(colorArg);
+        return this.#run((signal) => this.#protocol.setHsbk(color, { durationMs: durationMsArg, signal }), signalArg);
+    }
+    destroy() {
+        if (this.#closePromise)
+            return this.#closePromise;
+        this.#closed = true;
+        this.#healthy = false;
+        this.#parentSignal?.removeEventListener('abort', this.#onParentAbort);
+        this.#lifetime.abort(new Error('LIFX client is destroyed.'));
+        this.#closePromise = Promise.resolve().then(async () => {
+            const protocolClose = this.#protocol.close();
+            await Promise.allSettled([...this.#operations]);
+            await protocolClose;
+        });
+        return this.#closePromise;
+    }
+    #run(workArg, signalArg) {
+        if (this.#closed)
+            return Promise.reject(new Error('LIFX client is destroyed.'));
+        if (signalArg !== undefined && !(signalArg instanceof AbortSignal))
+            return Promise.reject(new TypeError('LIFX operation signal must be an AbortSignal.'));
+        if (signalArg?.aborted)
+            return Promise.reject(signalArg.reason);
+        const deadline = new AbortController();
+        const signal = AbortSignal.any([this.#lifetime.signal, deadline.signal, ...(signalArg ? [signalArg] : [])]);
+        const timer = setTimeout(() => deadline.abort(new Error('LIFX operation deadline exceeded.')), this.#config.requestTimeoutMs);
+        timer.unref();
+        const operation = Promise.resolve().then(() => {
+            signal.throwIfAborted();
+            return workArg(signal);
+        }).then((resultArg) => {
+            this.#healthy = !this.#closed && !signal.aborted;
+            return resultArg;
+        }, (errorArg) => {
+            this.#healthy = false;
+            throw errorArg;
+        }).finally(() => {
+            clearTimeout(timer);
+            this.#operations.delete(operation);
+        });
+        this.#operations.add(operation);
+        return operation;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlmeC5jbGFzc2VzLmNsaWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy9saWZ4L2xpZnguY2xhc3Nlcy5jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFeEQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRTlDLE1BQU0sT0FBTyxVQUFXLFNBQVEsaUJBQThCO0lBQzVELFlBQVksU0FBc0I7UUFDaEMsS0FBSyxDQUFDLFdBQVcsRUFBRSxTQUFTLENBQUMsQ0FBQztJQUNoQyxDQUFDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,5 @@
-import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IConfigFlow, IConfigFlowContext, IConfigFlowStep, IDiscoveryCandidate } from '../../core/types.js';
 import type { ILifxConfig } from './lifx.types.js';
-export declare class LifxConfigFlow extends SimpleLocalConfigFlow<ILifxConfig> {
-    constructor();
+export declare class LifxConfigFlow implements IConfigFlow<ILifxConfig> {
+    start(candidateArg: IDiscoveryCandidate, contextArg: IConfigFlowContext): Promise<IConfigFlowStep<ILifxConfig>>;
 }

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

@@ -1,8 +1,39 @@
-import { SimpleLocalConfigFlow } from '../../core/index.js';
-import { lifxProfile } from './lifx.types.js';
-export class LifxConfigFlow extends SimpleLocalConfigFlow {
-    constructor() {
-        super(lifxProfile);
+import { LifxClient } from './lifx.classes.client.js';
+import { createLifxDiscoveryDescriptor } from './lifx.discovery.js';
+import { assertLifxStoreScope, lifxKeys, lifxRecord, normalizeLifxConfig } from './lifx.validation.js';
+export class LifxConfigFlow {
+    async start(candidateArg, contextArg) {
+        const matched = await createLifxDiscoveryDescriptor().getValidators()[0].validate(candidateArg, {});
+        if (!matched.matched || !matched.candidate)
+            return { kind: 'error', error: matched.reason };
+        const candidate = matched.candidate;
+        return {
+            kind: 'form', title: 'Connect explicit LIFX LAN device',
+            description: 'Provide the authorized home and acknowledge the unauthenticated cleartext LAN protocol. The endpoint and MAC are fixed to this candidate.',
+            fields: [
+                { name: 'homeId', label: 'Home id', type: 'text', required: true },
+                { name: 'allowUnencryptedLan', label: 'Acknowledge unauthenticated cleartext LAN', type: 'boolean', required: true },
+                { name: 'name', label: 'Name', type: 'text' },
+            ],
+            submit: async (valuesArg) => {
+                let client;
+                try {
+                    const values = lifxRecord(valuesArg, 'config flow values');
+                    lifxKeys(values, ['homeId', 'allowUnencryptedLan', 'name', 'requestTimeoutMs', 'maxPendingOperations']);
+                    const config = normalizeLifxConfig({ ...values, host: candidate.host, port: candidate.port, macAddress: candidate.macAddress });
+                    assertLifxStoreScope(contextArg.configStore, config.homeId);
+                    client = new LifxClient(config);
+                    await client.getSnapshot();
+                    return { kind: 'done', title: 'LIFX device validated', config };
+                }
+                catch (errorArg) {
+                    return { kind: 'error', error: errorArg instanceof Error ? errorArg.message : 'LIFX setup validation failed.' };
+                }
+                finally {
+                    await client?.destroy();
+                }
+            },
+        };
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlmeC5jbGFzc2VzLmNvbmZpZ2Zsb3cuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvbGlmeC9saWZ4LmNsYXNzZXMuY29uZmlnZmxvdy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUU1RCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFOUMsTUFBTSxPQUFPLGNBQWUsU0FBUSxxQkFBa0M7SUFDcEU7UUFDRSxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDckIsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,11 +1,26 @@
-import { SimpleLocalIntegration } from '../../core/index.js';
+import { BaseIntegration } from '../../core/classes.baseintegration.js';
+import type { IIntegrationRuntime, IIntegrationSetupContext } from '../../core/types.js';
 import { LifxConfigFlow } from './lifx.classes.configflow.js';
 import type { ILifxConfig } from './lifx.types.js';
-export declare class LifxIntegration extends SimpleLocalIntegration<ILifxConfig> {
+export declare class LifxIntegration extends BaseIntegration<ILifxConfig> {
+    #private;
     readonly domain = "lifx";
-    readonly discoveryDescriptor: import("../../core/classes.discoverydescriptor.js").DiscoveryDescriptor;
+    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'];
+        };
+    };
+    readonly discoveryDescriptor: import("../../index.js").DiscoveryDescriptor;
     readonly configFlow: LifxConfigFlow;
-    constructor();
+    setup(configArg: ILifxConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime>;
+    destroy(): Promise<void>;
 }
 export declare class HomeAssistantLifxIntegration extends LifxIntegration {
 }

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'];
+        };
+    };
+};