@johanwistbacka/node-red-contrib-sw-light 0.1.4

package/examples/manual-adaptive.json

@@ -0,0 +1,228 @@
+[
+  {
+    "id": "sw-example-manual-adaptive",
+    "type": "tab",
+    "label": "SW Light \u2014 manual and adaptive",
+    "disabled": false,
+    "info": "Development example. Select your own Home Assistant server and light before deployment. No HA credentials are included."
+  },
+  {
+    "id": "sw-example-manual-adaptive-note",
+    "type": "comment",
+    "z": "sw-example-manual-adaptive",
+    "name": "Select HA server + light in SW Light before deploy",
+    "info": "Adaptive apply is off by default. Select your Adaptive Lighting switch and enable optional color-only apply if desired.",
+    "x": 350,
+    "y": 60,
+    "wires": []
+  },
+  {
+    "id": "sw-example-manual-adaptive-inject-0",
+    "type": "inject",
+    "z": "sw-example-manual-adaptive",
+    "name": "Manual 100%",
+    "props": [
+      {
+        "p": "action",
+        "v": "on",
+        "vt": "str"
+      },
+      {
+        "p": "source",
+        "v": "manual",
+        "vt": "str"
+      },
+      {
+        "p": "brightness_pct",
+        "v": "100",
+        "vt": "num"
+      }
+    ],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "x": 180,
+    "y": 120,
+    "wires": [
+      [
+        "sw-example-manual-adaptive-light"
+      ]
+    ]
+  },
+  {
+    "id": "sw-example-manual-adaptive-inject-1",
+    "type": "inject",
+    "z": "sw-example-manual-adaptive",
+    "name": "Automatic OFF (protected)",
+    "props": [
+      {
+        "p": "action",
+        "v": "off",
+        "vt": "str"
+      }
+    ],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "x": 180,
+    "y": 180,
+    "wires": [
+      [
+        "sw-example-manual-adaptive-light"
+      ]
+    ]
+  },
+  {
+    "id": "sw-example-manual-adaptive-inject-2",
+    "type": "inject",
+    "z": "sw-example-manual-adaptive",
+    "name": "Manual 50%",
+    "props": [
+      {
+        "p": "action",
+        "v": "on",
+        "vt": "str"
+      },
+      {
+        "p": "source",
+        "v": "manual",
+        "vt": "str"
+      },
+      {
+        "p": "brightness_pct",
+        "v": "50",
+        "vt": "num"
+      }
+    ],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "x": 180,
+    "y": 240,
+    "wires": [
+      [
+        "sw-example-manual-adaptive-light"
+      ]
+    ]
+  },
+  {
+    "id": "sw-example-manual-adaptive-inject-3",
+    "type": "inject",
+    "z": "sw-example-manual-adaptive",
+    "name": "Explicit latch",
+    "props": [
+      {
+        "p": "action",
+        "v": "on",
+        "vt": "str"
+      },
+      {
+        "p": "source",
+        "v": "manual",
+        "vt": "str"
+      },
+      {
+        "p": "manual_override",
+        "v": "true",
+        "vt": "bool"
+      }
+    ],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "x": 180,
+    "y": 300,
+    "wires": [
+      [
+        "sw-example-manual-adaptive-light"
+      ]
+    ]
+  },
+  {
+    "id": "sw-example-manual-adaptive-inject-4",
+    "type": "inject",
+    "z": "sw-example-manual-adaptive",
+    "name": "Release latch",
+    "props": [
+      {
+        "p": "action",
+        "v": "on",
+        "vt": "str"
+      },
+      {
+        "p": "source",
+        "v": "manual",
+        "vt": "str"
+      },
+      {
+        "p": "manual_override",
+        "v": "false",
+        "vt": "bool"
+      }
+    ],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "x": 180,
+    "y": 360,
+    "wires": [
+      [
+        "sw-example-manual-adaptive-light"
+      ]
+    ]
+  },
+  {
+    "id": "sw-example-manual-adaptive-light",
+    "type": "sw-light",
+    "z": "sw-example-manual-adaptive",
+    "name": "SW Light",
+    "server": "",
+    "entityId": "",
+    "x": 460,
+    "y": 210,
+    "wires": [
+      [
+        "sw-example-manual-adaptive-result"
+      ],
+      [
+        "sw-example-manual-adaptive-events"
+      ]
+    ],
+    "action": "msg"
+  },
+  {
+    "id": "sw-example-manual-adaptive-result",
+    "type": "debug",
+    "z": "sw-example-manual-adaptive",
+    "name": "result",
+    "active": true,
+    "tosidebar": true,
+    "console": false,
+    "tostatus": false,
+    "complete": "true",
+    "targetType": "full",
+    "x": 710,
+    "y": 180,
+    "wires": []
+  },
+  {
+    "id": "sw-example-manual-adaptive-events",
+    "type": "debug",
+    "z": "sw-example-manual-adaptive",
+    "name": "events",
+    "active": true,
+    "tosidebar": true,
+    "console": false,
+    "tostatus": false,
+    "complete": "true",
+    "targetType": "full",
+    "x": 710,
+    "y": 260,
+    "wires": []
+  }
+]

package/lib/adaptive.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { fault } = require('./light');
+
+function lights(state) {
+    const a = state?.attributes || {};
+    const list = a.configuration?.lights ?? a.lights;
+    return Array.isArray(list) ? list : [];
+}
+function select(c, states) {
+    if (c.adaptiveEntity) return c.adaptiveEntity;
+    if (!c.adaptiveDiscover) return null;
+    const candidates = Object.values(states).filter(s => s.entity_id?.startsWith('switch.') &&
+        lights(s).includes(c.entityId) &&
+        (s.attributes?.configuration || Array.isArray(s.attributes?.manual_control)));
+    return candidates.length === 1 ? candidates[0].entity_id : null;
+}
+function inspect(c, states) {
+    const entityId = select(c, states), state = entityId ? states[entityId] : null;
+    const a = state?.attributes || {};
+    // Conservatively respect either color-specific or aggregate manual control.
+    const manual = [a.manual_control, a.manual_control_color].some(list => Array.isArray(list) && list.includes(c.entityId));
+    return { entity_id: entityId, active: c.colorMode === 'adaptive' && state?.state === 'on',
+        manual_control: manual, state: state?.state ?? null };
+}
+async function apply(adapter, c, command) {
+    if (c.colorMode !== 'adaptive' || !c.adaptiveApply || !command.turningOn || command.explicitColor) return { applied: false };
+    const info = inspect(c, adapter.states());
+    if (!info.entity_id) throw fault('Select an Adaptive Lighting switch; discovery found no unique match', 'unsupported');
+    if (!info.active) return { applied: false, reason: 'switch_not_on' };
+    if (c.adaptiveRespectManual && info.manual_control) return { applied: false, reason: 'manual_control' };
+    if (!adapter.services()?.adaptive_lighting?.apply) throw fault('Adaptive Lighting apply service is unavailable', 'unsupported');
+    await adapter.call('adaptive_lighting', 'apply', {
+        entity_id: info.entity_id, lights: [c.entityId], adapt_brightness: false,
+        adapt_color: true, turn_on_lights: false
+    });
+    return { applied: true };
+}
+module.exports = { select, inspect, apply };

package/lib/ha-adapter.js

@@ -0,0 +1,138 @@
+'use strict';
+
+const { createRequire } = require('node:module');
+const path = require('node:path');
+const { fault } = require('./light');
+const PACKAGE = 'node-red-contrib-home-assistant-websocket';
+
+// This is the ONLY module allowed to depend on HA contrib's internal APIs.
+// Inspect the published package before adding another version to this allowlist.
+function loadIntegration(RED, diagnostic = () => {}) {
+    // Use one standard Node module resolution anchored at the runtime userDir.
+    // No cache scanning, alternate installation search or checkout fallback.
+    if (!RED.settings?.userDir) throw fault('Node-RED user directory is not available', 'unsupported');
+    let packagePath;
+    try { packagePath = createRequire(path.join(RED.settings.userDir, 'package.json')).resolve(`${PACKAGE}/package.json`); }
+    catch (_) { throw fault(`Install ${PACKAGE}@0.80.3 in the Node-RED user directory`, 'unsupported'); }
+    const req = createRequire(packagePath), metadata = req(packagePath);
+    if (metadata.version !== '0.80.3') throw fault(`Unsupported HA contrib ${metadata.version}; adapter verified against 0.80.3`, 'unsupported');
+    diagnostic(`providerVersion=${metadata.version} resolution=runtime-userDir`);
+    const integration = req('./dist/homeAssistant/index.js');
+    if (typeof integration.getHomeAssistant !== 'function') throw fault('HA contrib client API changed', 'unsupported');
+    return integration;
+}
+function createAdapter(RED, serverId, integration, diagnostic = () => {}) {
+    integration = integration || loadIntegration(RED, diagnostic);
+    // Construct a handle, not a ready client. Resolve the provider on each input.
+    let ha, stopped = false, observers, installing = false;
+    const listeners = [], subscriptions = new Set(), rawStates = new Map();
+    let pendingSubscription = Promise.resolve();
+    const diagnostics = new Map();
+    function report(server, client, phase) {
+        const info = { phase, serverIdPresent: Boolean(serverId), serverResolved: Boolean(server),
+            serverTypeIsServer: server?.type === 'server', serverConstructor: server?.constructor?.name || 'absent',
+            configPresent: Boolean(server?.config), configNodeClientPresent: Boolean(server?.homeAssistant),
+            configNodeGetState: typeof server?.getState === 'function', configNodeCallService: typeof server?.callService === 'function',
+            providerAccessor: typeof integration.getHomeAssistant === 'function', clientPresent: Boolean(client),
+            websocketPresent: Boolean(client?.websocket), getState: typeof client?.websocket?.getState === 'function',
+            callService: typeof client?.websocket?.callService === 'function', subscribeMessage: typeof client?.websocket?.subscribeMessage === 'function',
+            eventBus: typeof client?.eventBus?.on === 'function', connected: Boolean(client?.isConnected),
+            statesLoaded: Boolean(client?.websocket?.isStatesLoaded) };
+        const line = JSON.stringify(info);
+        if (line !== diagnostics.get(phase)) { diagnostics.set(phase, line); diagnostic(line); }
+    }
+    function connected() { return Boolean(!stopped && ha?.isConnected && ha.websocket.isStatesLoaded); }
+    function listen(event, callback) {
+        ha.eventBus.on(event, callback);
+        listeners.push([ha.eventBus, event, callback]);
+    }
+    async function detach() {
+        for (const [bus, event, fn] of listeners) bus.removeListener(event, fn);
+        listeners.length = 0;
+        await pendingSubscription;
+        await Promise.allSettled([...subscriptions].map(fn => Promise.resolve().then(fn)));
+        subscriptions.clear();
+        rawStates.clear();
+    }
+    async function install() {
+        if (stopped || installing || subscriptions.size || !connected() || !observers) return;
+        installing = true;
+        const client = ha;
+        try {
+            const unsubscribe = await client.websocket.subscribeMessage(event => {
+                if (stopped || ha !== client || event.data?.entity_id !== observers.entityId) return;
+                const state = event.data.new_state;
+                rawStates.set(observers.entityId, state ?? undefined);
+                try { observers.onState(state); } catch (error) { observers.onError(error); }
+            }, { type: 'subscribe_events', event_type: 'state_changed' }, { resubscribe: true });
+            if (stopped || ha !== client) await unsubscribe();
+            else subscriptions.add(unsubscribe);
+        } catch (error) { if (!stopped) observers.onError(error); }
+        finally { installing = false; }
+    }
+    function refresh() {
+        rawStates.clear();
+        if (!stopped && observers) {
+            observers.onConnection(connected());
+            if (!installing && !subscriptions.size && connected()) pendingSubscription = install();
+        }
+    }
+    function bind() {
+        if (!ha || !observers || stopped || listeners.length) return;
+        for (const event of ['ha_client:ready', 'ha_client:states_loaded', 'ha_client:connected']) listen(event, refresh);
+        for (const event of ['ha_client:close', 'ha_client:connecting', 'ha_client:error']) {
+            listen(event, () => { rawStates.clear(); if (!stopped) observers.onConnection(false); });
+        }
+        refresh();
+    }
+    return {
+        connected,
+        async resolve() {
+            if (stopped) throw fault('HA NOT READY: node closed', 'unavailable');
+            const server = RED.nodes.getNode(serverId);
+            report(server, undefined, 'server-resolution');
+            if (!server || server.type !== 'server') throw fault('CONFIG ERROR: selected HA server is missing or invalid', 'config_error');
+            if (!server.config) throw fault('HA NOT READY: server config is still initializing', 'unavailable');
+            if (server.config.addon === false && typeof integration.hasCredentials === 'function' &&
+                !integration.hasCredentials(server.credentials || {})) {
+                throw fault('CONFIG ERROR: HA server credentials are not configured', 'config_error');
+            }
+            // Same accessor as provider Action/Current State. The provider owns
+            // initialization/reuse and authentication; no independent client.
+            let next;
+            try { next = integration.getHomeAssistant(server); }
+            catch (_) { report(server, undefined, 'provider-accessor-threw'); throw fault('HA NOT READY: provider could not supply its client', 'unavailable'); }
+            report(server, next, 'provider-client');
+            if (!next || typeof next.websocket?.getState !== 'function' ||
+                typeof next.websocket?.subscribeMessage !== 'function' || !next.eventBus) {
+                throw fault('HA NOT READY: Home Assistant server client is not initialized', 'unavailable');
+            }
+            if (next !== ha) {
+                await detach();
+                if (stopped) throw fault('HA NOT READY: node closed', 'unavailable');
+                ha = next;
+                bind();
+            } else if (observers && !installing && !subscriptions.size && connected()) {
+                pendingSubscription = install();
+            }
+        },
+        state: id => rawStates.has(id) ? structuredClone(rawStates.get(id)) : ha?.websocket.getState(id),
+        states: () => ha?.websocket.getStates() || {},
+        services: () => ha?.websocket.getServices() || {},
+        async call(domain, service, data, target) {
+            if (!connected()) throw fault('HA NOT READY: disconnected or loading states', 'unavailable');
+            return ha.websocket.callService(domain, service, data, target);
+        },
+        async subscribe(entityId, onState, onConnection, onError) {
+            observers = { entityId, onState, onConnection, onError };
+            bind();
+        },
+        async close() {
+            stopped = true;
+            await detach();
+            ha = undefined;
+        }
+    };
+}
+
+module.exports = { loadIntegration, createAdapter };

package/lib/light.js

@@ -0,0 +1,200 @@
+'use strict';
+
+const DEFAULTS = Object.freeze({
+    action: 'msg',
+    brightnessPct: 94, autoMaxPct: 94, minPct: 1, transitionOn: 1,
+    transitionOff: 1, manualOverride: true, overrideThreshold: 100,
+    overrideStrategy: 'threshold', colorMode: 'adaptive', kelvin: 2700,
+    mired: 370, fixedColor: '#ffffff', adaptiveEntity: '',
+    adaptiveDiscover: true, adaptiveApply: false, adaptiveRespectManual: true
+});
+const COLOR_KEYS = ['color_temp_kelvin', 'color_temp', 'rgbww_color', 'rgbw_color',
+    'rgb_color', 'hs_color', 'xy_color', 'color_name'];
+const BRIGHTNESS_KEYS = ['brightness_pct', 'brightness', 'brightness_step_pct', 'brightness_step'];
+const own = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+
+function fault(message, type = 'error') {
+    const error = new Error(message);
+    error.eventType = type;
+    return error;
+}
+function number(value, name, min, max, integer = false) {
+    if ((typeof value !== 'number' && typeof value !== 'string') ||
+        (typeof value === 'string' && !value.trim())) throw fault(`${name} must be numeric`);
+    const n = Number(value);
+    if (!Number.isFinite(n) || n < min || n > max || (integer && !Number.isInteger(n))) {
+        throw fault(`${name} must be ${integer ? 'an integer ' : ''}between ${min} and ${max}`);
+    }
+    return n;
+}
+function boolean(value, name) {
+    if (value === true || value === 'true') return true;
+    if (value === false || value === 'false') return false;
+    throw fault(`${name} must be boolean`);
+}
+function config(raw) {
+    const c = { ...DEFAULTS, ...raw };
+    if (!['on', 'off', 'toggle', 'msg'].includes(c.action)) throw fault('Invalid configured action');
+    for (const key of ['brightnessPct', 'autoMaxPct', 'minPct', 'overrideThreshold']) {
+        c[key] = number(c[key], key, key === 'minPct' || key === 'overrideThreshold' ? 1 : 0, 100);
+    }
+    if (c.minPct > c.autoMaxPct || c.brightnessPct < c.minPct || c.brightnessPct > c.autoMaxPct) {
+        throw fault('Require minPct <= brightnessPct <= autoMaxPct');
+    }
+    for (const key of ['transitionOn', 'transitionOff']) c[key] = number(c[key], key, 0, 3600);
+    for (const key of ['manualOverride', 'adaptiveDiscover', 'adaptiveApply', 'adaptiveRespectManual']) {
+        c[key] = boolean(c[key], key);
+    }
+    if (c.manualOverride && c.overrideStrategy === 'threshold' && c.autoMaxPct >= c.overrideThreshold) {
+        throw fault('Automatic maximum must be below the manual override threshold');
+    }
+    if (!['threshold', 'explicit'].includes(c.overrideStrategy)) throw fault('Invalid override strategy');
+    if (!['adaptive', 'keep', 'kelvin', 'mired', 'default', 'color'].includes(c.colorMode)) throw fault('Invalid color mode');
+    c.kelvin = number(c.kelvin, 'kelvin', 1000, 40000, true);
+    c.mired = number(c.mired, 'mired', 25, 1000);
+    if (!/^#[0-9a-f]{6}$/i.test(c.fixedColor)) throw fault('Fixed color must be #rrggbb');
+    if (c.adaptiveEntity && !/^switch\.[a-z0-9_]+$/.test(c.adaptiveEntity)) throw fault('Adaptive entity must be a switch entity');
+    if (!/^light\.[a-z0-9_]+$/.test(c.entityId || '')) throw fault('Select a light entity');
+    return c;
+}
+function pct(brightness) { return brightness * 100 / 255; }
+function byte(percent) { return Math.round(percent * 255 / 100); }
+function capabilities(state) {
+    const a = state?.attributes || {};
+    const modes = Array.isArray(a.supported_color_modes) ? a.supported_color_modes : [];
+    return { modes, brightness: modes.some(m => ['brightness','color_temp','hs','xy','rgb','rgbw','rgbww','white'].includes(m)),
+        transition: Boolean((Number(a.supported_features) || 0) & 32) };
+}
+function vector(value, key, limits) {
+    if (!Array.isArray(value) || value.length !== limits.length) throw fault(`${key} requires ${limits.length} values`);
+    return value.map((n, i) => number(n, `${key}[${i}]`, 0, limits[i], limits[i] === 255));
+}
+function rgbToHs(rgb) {
+    const [r, g, b] = rgb.map(v => v / 255), max = Math.max(r, g, b), min = Math.min(r, g, b), d = max - min;
+    let h = 0;
+    if (d) h = max === r ? ((g - b) / d + 6) % 6 : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
+    return [h * 60, max ? d / max * 100 : 0];
+}
+function hsToRgb([h, s]) {
+    s /= 100;
+    const f = n => { const k = (n + h / 60) % 6; return Math.round(255 * (1 - s * Math.max(0, Math.min(k, 4 - k, 1)))); };
+    return [f(5), f(3), f(1)];
+}
+function rgbToXy(rgb) {
+    const [r, g, b] = rgb.map(v => { v /= 255; return v > 0.04045 ? ((v + 0.055) / 1.055) ** 2.4 : v / 12.92; });
+    const x = r * 0.664511 + g * 0.154324 + b * 0.162028;
+    const y = r * 0.283881 + g * 0.668433 + b * 0.047685;
+    const z = r * 0.000088 + g * 0.072310 + b * 0.986039;
+    return x + y + z ? [x / (x + y + z), y / (x + y + z)] : [0, 0];
+}
+function normalizeColor(key, value) {
+    if (key === 'color_temp_kelvin') return { kind: 'kelvin', value: number(value, key, 1000, 40000, true) };
+    if (key === 'color_temp') return { kind: 'kelvin', value: Math.round(1000000 / number(value, key, 25, 1000)) };
+    const lengths = { rgb_color: [255,255,255], rgbw_color: [255,255,255,255], rgbww_color: [255,255,255,255,255], hs_color: [360,100], xy_color: [1,1] };
+    if (lengths[key]) return { kind: key, value: vector(value, key, lengths[key]) };
+    if (typeof value !== 'string' || !/^[a-zA-Z][a-zA-Z ]{0,39}$/.test(value)) throw fault('Invalid color_name');
+    return { kind: key, value };
+}
+function colorPayload(color, state) {
+    const modes = capabilities(state).modes, a = state.attributes || {};
+    const { kind, value } = color;
+    if (kind === 'kelvin') {
+        if (!modes.includes('color_temp')) return null;
+        const min = a.min_color_temp_kelvin ?? (a.max_mireds ? Math.ceil(1000000 / a.max_mireds) : 1000);
+        const max = a.max_color_temp_kelvin ?? (a.min_mireds ? Math.floor(1000000 / a.min_mireds) : 40000);
+        if (value < min || value > max) throw fault(`Color temperature outside lamp range ${min}–${max} K`);
+        return { color_temp_kelvin: value };
+    }
+    if (kind === 'color_name') return modes.some(m => ['hs','xy','rgb','rgbw','rgbww'].includes(m)) ? { color_name: value } : null;
+    if (modes.includes(kind.replace('_color', ''))) return { [kind]: value };
+    // Preserve white channels: never silently discard RGBW/RGBWW channels.
+    if (!['rgb_color', 'hs_color'].includes(kind)) return null;
+    const rgb = kind === 'rgb_color' ? value : hsToRgb(value);
+    if (modes.includes('rgb')) return { rgb_color: rgb };
+    if (modes.includes('hs')) return { hs_color: rgbToHs(rgb) };
+    if (modes.includes('xy')) return { xy_color: rgbToXy(rgb) };
+    if (modes.includes('rgbw')) return { rgbw_color: [...rgb, 0] };
+    if (modes.includes('rgbww')) return { rgbww_color: [...rgb, 0, 0] };
+    return null;
+}
+class Override {
+    constructor(c) { this.c = c; this.threshold = false; this.explicit = false; }
+    get active() { return this.c.manualOverride && (this.threshold || this.explicit); }
+    observe(state) {
+        if (!this.c.manualOverride) return;
+        if (state?.state === 'off') { this.threshold = false; this.explicit = false; }
+        else if (state?.state === 'on' && this.c.overrideStrategy === 'threshold' && Number.isFinite(state.attributes?.brightness)) {
+            // Compare bytes to avoid treating 254/255 as 100%.
+            this.threshold = state.attributes.brightness >= byte(this.c.overrideThreshold);
+        }
+    }
+    set(value) { this.explicit = boolean(value, 'manual_override'); if (!this.explicit) this.threshold = false; }
+}
+function resolveAction(c, msg) {
+    const action = c.action === 'msg' ? (own(msg, 'action') ? msg.action : msg.auto_light?.action) : c.action;
+    if (!['on', 'off', 'toggle'].includes(action)) throw fault('Action must be on, off or toggle; From msg requires msg.action (or msg.auto_light.action)');
+    return action;
+}
+function plan(c, msg, state, overrideActive) {
+    const action = resolveAction(c, msg);
+    const source = msg.source ?? 'automatic';
+    if (!['automatic', 'manual'].includes(source)) throw fault('msg.source must be automatic or manual');
+    const turningOn = action === 'on' || (action === 'toggle' && state.state === 'off');
+    const cap = capabilities(state), data = {}, unsupported = [];
+    const bKeys = BRIGHTNESS_KEYS.filter(k => own(msg, k));
+    // Validate even lower-precedence properties, so bad input never disappears silently.
+    const validated = {};
+    for (const key of bKeys) validated[key] = number(msg[key], key, key.includes('step') ? (key.endsWith('pct') ? -100 : -255) : 0, key.endsWith('pct') ? 100 : 255, !key.endsWith('pct'));
+    const colors = COLOR_KEYS.filter(k => own(msg, k)).map(k => [k, normalizeColor(k, msg[k])]);
+    const transition = own(msg, 'transition') ? number(msg.transition, 'transition', 0, 3600) : turningOn ? c.transitionOn : c.transitionOff;
+    if (cap.transition) data.transition = transition;
+    else if (own(msg, 'transition')) unsupported.push('transition');
+    let zero = false;
+    if (turningOn) {
+        let level = c.brightnessPct;
+        if (bKeys.length) {
+            const key = bKeys[0], value = validated[key];
+            if (key.includes('step')) {
+                const current = state.state === 'off' ? 0 : state.attributes?.brightness;
+                if (!Number.isFinite(current)) throw fault('Brightness steps require a known brightness');
+                level = pct(current) + (key.endsWith('pct') ? value : pct(value));
+                level = Math.max(0, Math.min(100, level));
+            } else level = key.endsWith('pct') ? value : pct(value);
+        }
+        zero = level === 0 && cap.brightness;
+        if (cap.brightness && !zero) {
+            level = Math.max(c.minPct, Math.min(source === 'automatic' ? c.autoMaxPct : 100, level));
+            data.brightness = Math.min(byte(level), source === 'automatic' ? Math.floor(c.autoMaxPct * 255 / 100) : 255);
+        } else if (bKeys.length && !cap.brightness) unsupported.push(...bKeys);
+        let color = colors[0]?.[1];
+        if (!color && c.colorMode === 'kelvin') color = normalizeColor('color_temp_kelvin', c.kelvin);
+        if (!color && c.colorMode === 'mired') color = normalizeColor('color_temp', c.mired);
+        if (!color && c.colorMode === 'color') color = normalizeColor('rgb_color', c.fixedColor.match(/[0-9a-f]{2}/gi).map(v => parseInt(v, 16)));
+        if (color && !zero) {
+            const payload = colorPayload(color, state);
+            if (payload) Object.assign(data, payload);
+            else unsupported.push(colors[0]?.[0] || c.colorMode);
+        }
+    } else unsupported.push(...bKeys, ...colors.map(([key]) => key));
+    if (zero) {
+        for (const key of Object.keys(data)) if (key !== 'transition') delete data[key];
+        if (!own(msg, 'transition') && cap.transition) data.transition = c.transitionOff;
+    }
+    return { action, source, service: turningOn && !zero ? 'turn_on' : 'turn_off',
+        turningOn: turningOn && !zero, data, unsupported,
+        blocked: source === 'automatic' && overrideActive,
+        explicitColor: colors.length > 0,
+        ignoredConflicts: [...bKeys.slice(1), ...colors.slice(1).map(([key]) => key)] };
+}
+function normalized(state, override, adaptive, action) {
+    const a = state?.attributes || {};
+    return { entity_id: state?.entity_id, state: state?.state ?? 'missing',
+        brightness: a.brightness ?? null, brightness_pct: Number.isFinite(a.brightness) ? Math.round(pct(a.brightness) * 10) / 10 : null,
+        color_mode: a.color_mode ?? null, color_temp_kelvin: a.color_temp_kelvin ?? (a.color_temp ? Math.round(1000000 / a.color_temp) : null),
+        color_temp: a.color_temp ?? null,
+        color: Object.fromEntries(['rgb_color','rgbw_color','rgbww_color','hs_color','xy_color'].filter(k => a[k] !== undefined).map(k => [k, [...a[k]]])),
+        manual_override: override, adaptive_lighting: adaptive, action,
+        observed_at: state?.last_updated ?? null };
+}
+module.exports = { DEFAULTS, COLOR_KEYS, BRIGHTNESS_KEYS, config, number, fault, pct, byte, capabilities, resolveAction,
+    normalizeColor, colorPayload, Override, plan, normalized };