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

package/lib/adaptive.js

@@ -2,38 +2,48 @@
 
 const { fault } = require('./light');
 
-function lights(state) {
-    const a = state?.attributes || {};
-    const list = a.configuration?.lights ?? a.lights;
-    return Array.isArray(list) ? list : [];
+// Main Adaptive Lighting switches expose configuration.lights in upstream
+// extra_state_attributes. Auxiliary switches do not. Never infer entity names.
+function candidates(c, states) {
+    return Object.values(states).filter(s => s.entity_id?.startsWith('switch.') &&
+        Array.isArray(s.attributes?.configuration?.lights) &&
+        s.attributes.configuration.lights.includes(c.entityId)).map(s => s.entity_id);
 }
 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;
+    const matches = candidates(c, states);
+    return matches.length === 1 ? matches[0] : 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 };
+    const matches = candidates(c, states), entityId = select(c, states);
+    const state = entityId ? states[entityId] : null;
+    return { entity_id: entityId, active: c.adaptiveEnabled && state?.state === 'off',
+        state: state?.state ?? null, candidates: matches };
 }
 async function apply(adapter, c, command) {
-    if (c.colorMode !== 'adaptive' || !c.adaptiveApply || !command.turningOn || command.explicitColor) return { applied: false };
+    if (!command.adaptiveEnabled || !command.offToOn || command.source !== 'automatic' || command.explicitColor) {
+        return { applied: false, reason: 'not_requested' };
+    }
+    if (!command.supportsTemperature) return { applied: false, reason: 'unsupported_color_temperature' };
     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');
+    const fail = (reason, message) => {
+        const error = fault(message, 'warning'); error.reason = reason; throw error;
+    };
+    if (!info.entity_id) fail(info.candidates.length > 1 ? 'ambiguous_configuration' : 'configuration_missing',
+        'Adaptive Lighting: no unique profile for this light; select a profile under Advanced.');
+    if (!['on', 'off'].includes(info.state)) fail('profile_unavailable', 'Adaptive Lighting profile is unavailable.');
+    // A running profile can intercept ON and continuously adapt brightness/color.
+    // One-shot apply also works with the main switch off, without installing listeners.
+    if (info.state !== 'off') fail('profile_running', 'Turn off the Adaptive Lighting main switch to use it as a one-shot profile.');
+    const configuration = adapter.states()[info.entity_id]?.attributes?.configuration;
+    if (configuration?.sleep_rgb_or_color_temp === 'rgb_color') fail('profile_uses_rgb',
+        'Adaptive Lighting profile uses RGB sleep color; choose a color-temperature sleep profile.');
+    if (!adapter.services()?.adaptive_lighting?.apply) fail('service_unavailable', 'Adaptive Lighting apply action is unavailable.');
     await adapter.call('adaptive_lighting', 'apply', {
         entity_id: info.entity_id, lights: [c.entityId], adapt_brightness: false,
-        adapt_color: true, turn_on_lights: false
+        adapt_color: true, prefer_rgb_color: false, turn_on_lights: true,
+        transition: command.data.transition ?? 0
     });
-    return { applied: true };
+    return { applied: true, entity_id: info.entity_id };
 }
-module.exports = { select, inspect, apply };
+module.exports = { candidates, select, inspect, apply };

package/lib/controller.js

@@ -0,0 +1,98 @@
+'use strict';
+const light = require('./light');
+const adaptive = require('./adaptive');
+
+// One independent controller per entity, shared by every target type.
+function createController(c, adapter, node, isClosed) {
+    const detector = new light.Override(c);
+    let lastAvailability;
+    const protectedAtFullBrightness = state => state?.state === 'on' && state.attributes?.brightness === 255;
+    const overrideActive = state => detector.active || protectedAtFullBrightness(state);
+    function event(type, detail = {}, msg = {}, send = node.send.bind(node)) {
+        if (isClosed()) return;
+        send([null, { ...msg, sw_light_event: { version: 1, type, entity_id: c.entityId,
+            timestamp: new Date().toISOString(), ...detail } }]);
+    }
+    function overrideUpdate(fn, msg, send) {
+        const before = detector.active;
+        fn();
+        if (before !== detector.active) event(detector.active ? 'manual_override' : 'override_released',
+            { active: detector.active, strategy: c.overrideStrategy }, msg, send);
+    }
+    function observe(state) {
+        if (isClosed()) return;
+        overrideUpdate(() => detector.observe(state));
+        const availability = !state ? 'missing' : state.state;
+        if (['missing', 'unknown', 'unavailable'].includes(availability)) {
+            node.status({ fill: 'red', shape: 'ring', text: 'ENTITY UNAVAILABLE' });
+            if (lastAvailability !== availability) event('unavailable', { reason: availability });
+        } else {
+            const active = overrideActive(state);
+            const info = light.normalized(state, active, c.adaptiveEnabled, 'state_changed');
+            let text = active ? 'MANUAL' : `AUTO · ${info.state.toUpperCase()}`;
+            if (info.state === 'on' && info.brightness_pct !== null) text += ` · ${info.brightness_pct}%`;
+            if (info.state === 'on' && info.color_temp_kelvin) text += ` · ${info.color_temp_kelvin}K`;
+            if (info.state === 'on' && c.adaptiveEnabled) text += ' · adaptive';
+            node.status({ fill: active ? 'yellow' : info.state === 'on' ? 'green' : 'grey', shape: 'dot', text });
+        }
+        lastAvailability = availability;
+    }
+
+    async function execute(msg, send) {
+        let command, serviceCompleted = false;
+        try {
+            const state = adapter.state(c.entityId);
+            if (!state || !['on', 'off'].includes(state.state)) throw light.fault(`Light is ${state?.state ?? 'missing'}`, 'unavailable');
+            observe(state);
+            const requestedOverride = Object.prototype.hasOwnProperty.call(msg, 'manual_override');
+            if (requestedOverride && (msg.source ?? 'automatic') !== 'manual') throw light.fault('manual_override requires source: manual');
+            if (requestedOverride && typeof msg.manual_override !== 'boolean') throw light.fault('manual_override must be boolean');
+            command = light.plan(c, msg, state, overrideActive(state));
+            if (requestedOverride) {
+                overrideUpdate(() => detector.set(msg.manual_override), msg, send);
+                command.blocked = false; // validated manual source
+            }
+            if (command.unsupported.length) event('unsupported', { parameters: command.unsupported, reason: 'lamp_capabilities_or_action' }, msg, send);
+            if (command.blocked) {
+                event('manual_override', { active: true, blocked: true, requested_action: command.action }, msg, send);
+                const percent = Number.isFinite(state.attributes?.brightness) ? Math.round(light.pct(state.attributes.brightness)) : '?';
+                node.status({ fill: 'yellow', shape: 'dot', text: `MANUAL · ${percent}% · BLOCK ${command.action.toUpperCase()}` });
+                return { ...light.normalized(state, overrideActive(state), command.adaptiveEnabled, command.service), entity_id: c.entityId, outcome: 'skipped', reason: 'manual_override', source: command.source, requested_action: command.action, state_confirmation: 'last_observed' };
+            }
+            await adapter.call('light', command.service, command.data, { entity_id: c.entityId });
+            serviceCompleted = true;
+            if (isClosed()) return { entity_id: c.entityId, outcome: 'skipped', reason: 'node_closed' };
+            let adaptiveResult;
+            try {
+                adaptiveResult = await adaptive.apply(adapter, c, command);
+                if (adaptiveResult.reason === 'unsupported_color_temperature') event('unsupported',
+                    { phase: 'adaptive_apply', reason: adaptiveResult.reason, light_service_completed: true }, msg, send);
+            }
+            catch (error) {
+                adaptiveResult = { applied: false, reason: error.reason || 'apply_failed' };
+                event('warning', { message: error.message, reason: adaptiveResult.reason,
+                    phase: 'adaptive_apply', light_service_completed: true }, msg, send);
+            }
+            if (isClosed()) return { entity_id: c.entityId, outcome: 'skipped', reason: 'node_closed' };
+            const current = adapter.state(c.entityId);
+            observe(current);
+            const result = { ...light.normalized(current, overrideActive(current), command.adaptiveEnabled, command.service),
+                entity_id: c.entityId, source: command.source, requested_action: command.action,
+                service_data: command.data, ignored_conflicts: command.ignoredConflicts,
+                state_confirmation: 'last_observed', adaptive: { ...adaptive.inspect({ ...c, adaptiveEnabled: command.adaptiveEnabled }, adapter.states()), ...adaptiveResult } };
+
+            const level = command.data.brightness === undefined ? '' : ` · ${Math.round(light.pct(command.data.brightness))}%`;
+            node.status({ fill: command.source === 'manual' ? 'yellow' : command.turningOn ? 'green' : 'grey', shape: 'dot',
+                text: `${command.source === 'manual' ? 'MANUAL' : 'AUTO'} · ${command.turningOn ? 'ON' : 'OFF'}${level}` });
+            return { ...result, outcome: 'succeeded' };
+        } catch (error) {
+            event(error.eventType || 'error', { message: error.message, light_service_completed: serviceCompleted }, msg, send);
+            if (!isClosed()) node.status({ fill: 'red', shape: 'ring', text: error.eventType === 'config_error' ? 'CONFIG ERROR' :
+                error.eventType === 'unavailable' ? (error.message.startsWith('HA NOT READY:') || !adapter || !adapter.connected() ? 'HA NOT READY' : 'ENTITY UNAVAILABLE') : error.message });
+            return { ...light.normalized(adapter.state(c.entityId), overrideActive(adapter.state(c.entityId)), c.adaptiveEnabled), entity_id: c.entityId, outcome: 'failed', error: { type: error.eventType || 'error', message: error.message }, light_service_completed: serviceCompleted, cause: error };
+        }
+
+    }
+    return { observe, execute, info: () => { const state = adapter.state(c.entityId); return light.normalized(state, overrideActive(state), c.adaptiveEnabled); } };
+}
+module.exports = { createController };

package/lib/ha-adapter.js

@@ -27,6 +27,13 @@ function createAdapter(RED, serverId, integration, diagnostic = () => {}) {
     let ha, stopped = false, observers, installing = false;
     const listeners = [], subscriptions = new Set(), rawStates = new Map();
     let pendingSubscription = Promise.resolve();
+    let registryBound = false, connectionBound = false;
+    let registryListener, registryCache, registryPending, registryGeneration = 0;
+    let entityIds = new Set();
+    function invalidateRegistries() {
+        registryGeneration++; registryCache = undefined;
+        if (!stopped) registryListener?.();
+    }
     const diagnostics = new Map();
     function report(server, client, phase) {
         const info = { phase, serverIdPresent: Boolean(serverId), serverResolved: Boolean(server),
@@ -48,11 +55,12 @@ function createAdapter(RED, serverId, integration, diagnostic = () => {}) {
     }
     async function detach() {
         for (const [bus, event, fn] of listeners) bus.removeListener(event, fn);
-        listeners.length = 0;
+        listeners.length = 0; registryBound = false; connectionBound = false;
         await pendingSubscription;
         await Promise.allSettled([...subscriptions].map(fn => Promise.resolve().then(fn)));
         subscriptions.clear();
         rawStates.clear();
+        invalidateRegistries();
     }
     async function install() {
         if (stopped || installing || subscriptions.size || !connected() || !observers) return;
@@ -60,10 +68,10 @@ function createAdapter(RED, serverId, integration, diagnostic = () => {}) {
         const client = ha;
         try {
             const unsubscribe = await client.websocket.subscribeMessage(event => {
-                if (stopped || ha !== client || event.data?.entity_id !== observers.entityId) return;
+                if (stopped || ha !== client || !entityIds.has(event.data?.entity_id)) return;
                 const state = event.data.new_state;
-                rawStates.set(observers.entityId, state ?? undefined);
-                try { observers.onState(state); } catch (error) { observers.onError(error); }
+                rawStates.set(event.data.entity_id, state ?? undefined);
+                try { observers.onState(state, event.data.entity_id); } catch (error) { observers.onError(error); }
             }, { type: 'subscribe_events', event_type: 'state_changed' }, { resubscribe: true });
             if (stopped || ha !== client) await unsubscribe();
             else subscriptions.add(unsubscribe);
@@ -72,16 +80,24 @@ function createAdapter(RED, serverId, integration, diagnostic = () => {}) {
     }
     function refresh() {
         rawStates.clear();
+        invalidateRegistries();
         if (!stopped && observers) {
             observers.onConnection(connected());
             if (!installing && !subscriptions.size && connected()) pendingSubscription = install();
         }
     }
+    function bindRegistries() {
+        if (!ha || !registryListener || registryBound || stopped) return;
+        registryBound = true;
+        for (const event of ['labels_updated', 'entity_registry_updated', 'devices_updated', 'areas_updated']) listen(event, invalidateRegistries);
+    }
     function bind() {
-        if (!ha || !observers || stopped || listeners.length) return;
+        bindRegistries();
+        if (!ha || !observers || stopped || connectionBound) return;
+        connectionBound = true;
         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); });
+            listen(event, () => { rawStates.clear(); invalidateRegistries(); if (!stopped) observers.onConnection(false); });
         }
         refresh();
     }
@@ -123,8 +139,36 @@ function createAdapter(RED, serverId, integration, diagnostic = () => {}) {
             if (!connected()) throw fault('HA NOT READY: disconnected or loading states', 'unavailable');
             return ha.websocket.callService(domain, service, data, target);
         },
+        onRegistryChange(callback) { registryListener = callback; bindRegistries(); },
+        async labels() {
+            if (!connected()) throw fault('HA NOT READY', 'unavailable');
+            return ha.websocket.send({ type: 'config/label_registry/list' });
+        },
+        async registries() {
+            if (!connected() || typeof ha.websocket.send !== 'function') throw fault('HA registries unavailable', 'target_resolution_failure');
+            if (registryCache && Date.now() - registryCache.time < 30000) return registryCache.data;
+            if (registryPending) return registryPending;
+            const generation = registryGeneration, client = ha;
+            const pending = Promise.all(['label', 'entity', 'device', 'area'].map(name =>
+                client.websocket.send({ type: `config/${name}_registry/list` }))).then(([labels, entities, devices, areas]) => {
+                if (stopped || ha !== client || generation !== registryGeneration) throw fault('HA registries changed during resolution; retry', 'target_resolution_failure');
+                const data = { labels, entities, devices, areas };
+                if (!Object.values(data).every(Array.isArray)) throw fault('Invalid HA registry response', 'target_resolution_failure');
+                registryCache = { time: Date.now(), data };
+                return data;
+            });
+            registryPending = pending;
+            try { return await pending; } finally { if (registryPending === pending) registryPending = undefined; }
+        },
+        async watch(ids, onState, onConnection, onError) {
+            entityIds = new Set(ids);
+            for (const id of rawStates.keys()) if (!entityIds.has(id)) rawStates.delete(id);
+            observers = { onState, onConnection, onError };
+            bind();
+        },
         async subscribe(entityId, onState, onConnection, onError) {
-            observers = { entityId, onState, onConnection, onError };
+            entityIds = new Set(entityId ? [entityId] : []);
+            observers = { onState, onConnection, onError };
             bind();
         },
         async close() {

package/lib/light.js

@@ -3,10 +3,9 @@
 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
+    transitionOff: 1, manualOverride: true, overrideThreshold: 98,
+    overrideStrategy: 'threshold', adaptiveEnabled: false, colorMode: 'keep', kelvin: 2700,
+    mired: 370, fixedColor: '#ffffff', adaptiveEntity: ''
 });
 const COLOR_KEYS = ['color_temp_kelvin', 'color_temp', 'rgbww_color', 'rgbw_color',
     'rgb_color', 'hs_color', 'xy_color', 'color_name'];
@@ -34,6 +33,11 @@ function boolean(value, name) {
 }
 function config(raw) {
     const c = { ...DEFAULTS, ...raw };
+    if (own(raw, 'adaptiveApply')) boolean(raw.adaptiveApply, 'adaptiveApply');
+    // Preserve opt-in from legacy flows; inactive legacy adaptive mode stays off.
+    c.adaptiveEnabled = own(raw, 'adaptiveEnabled') ? boolean(raw.adaptiveEnabled, 'adaptiveEnabled') :
+        raw.colorMode === 'adaptive' && boolean(raw.adaptiveApply ?? false, 'adaptiveApply');
+    if (c.colorMode === 'adaptive') c.colorMode = 'keep';
     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);
@@ -42,9 +46,7 @@ function config(raw) {
         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);
-    }
+    c.manualOverride = boolean(c.manualOverride, 'manualOverride');
     if (c.manualOverride && c.overrideStrategy === 'threshold' && c.autoMaxPct >= c.overrideThreshold) {
         throw fault('Automatic maximum must be below the manual override threshold');
     }
@@ -54,7 +56,10 @@ function config(raw) {
     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');
+    if ((c.targetType ?? 'entity') === 'entity' && !/^light\.[a-z0-9_]+$/.test(c.entityId || '')) throw fault('Select a light entity');
+    const configured = require('./targets').target(c);
+    c.targetType = configured.type;
+    if (configured.type === 'label') c.labelId = configured.id;
     return c;
 }
 function pct(brightness) { return brightness * 100 / 255; }
@@ -138,6 +143,7 @@ function resolveAction(c, msg) {
 function plan(c, msg, state, overrideActive) {
     const action = resolveAction(c, msg);
     const source = msg.source ?? 'automatic';
+    const adaptiveEnabled = own(msg, 'adaptive_lighting') ? boolean(msg.adaptive_lighting, 'adaptive_lighting') : c.adaptiveEnabled;
     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 = [];
@@ -180,8 +186,9 @@ function plan(c, msg, state, overrideActive) {
         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,
+    return { action, source, adaptiveEnabled, service: turningOn && !zero ? 'turn_on' : 'turn_off',
+        turningOn: turningOn && !zero, offToOn: turningOn && !zero && state.state === 'off',
+        supportsTemperature: cap.modes.includes('color_temp'), data, unsupported,
         blocked: source === 'automatic' && overrideActive,
         explicitColor: colors.length > 0,
         ignoredConflicts: [...bKeys.slice(1), ...colors.slice(1).map(([key]) => key)] };
@@ -192,7 +199,7 @@ function normalized(state, override, adaptive, action) {
         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]]])),
+        color: Object.fromEntries(['rgb_color','rgbw_color','rgbww_color','hs_color','xy_color'].filter(k => Array.isArray(a[k])).map(k => [k, [...a[k]]])),
         manual_override: override, adaptive_lighting: adaptive, action,
         observed_at: state?.last_updated ?? null };
 }

package/lib/targets.js

@@ -0,0 +1,54 @@
+'use strict';
+const { fault } = require('./light');
+
+function target(raw, override) {
+    const value = override === undefined ? { type: raw.targetType ?? 'entity', id: (raw.targetType ?? 'entity') === 'label' ? raw.labelId : raw.entityId } : override;
+    if (!value || typeof value !== 'object' || Array.isArray(value) || !['entity', 'label'].includes(value.type) ||
+        typeof value.id !== 'string' || !value.id.trim()) throw fault('Target requires type entity/label and a stable id', 'config_error');
+    if (value.type === 'entity' && !/^light\.[a-z0-9_]+$/.test(value.id)) throw fault('Select a light entity', 'config_error');
+    return { type: value.type, id: value.id };
+}
+
+// HA 2026.9 service target semantics. Area relationships are part of Label
+// expansion; Area is deliberately not exposed as a configured target type.
+function labelLights(id, { labels, entities, devices, areas }) {
+    if (![labels, entities, devices, areas].every(Array.isArray)) throw fault('HA registries unavailable', 'target_resolution_failure');
+    if (!labels.some(l => l.label_id === id)) throw fault(`Label ${id} was deleted or does not exist`, 'target_resolution_failure');
+    const marked = item => Array.isArray(item.labels) && item.labels.includes(id);
+    const deviceIds = new Set(devices.filter(marked).map(d => d.id));
+    const areaIds = new Set(areas.filter(marked).map(a => a.area_id));
+    const areaDevices = new Set(devices.filter(d => areaIds.has(d.area_id)).map(d => d.id));
+    return [...new Set(entities.filter(e => {
+        if (!/^light\.[a-z0-9_]+$/.test(e.entity_id) || e.hidden_by || e.disabled_by) return false;
+        if (marked(e)) return true;
+        if (e.entity_category) return false;
+        return deviceIds.has(e.device_id) || areaIds.has(e.area_id) || (!e.area_id && areaDevices.has(e.device_id));
+    }).map(e => e.entity_id))].sort();
+}
+async function resolveTarget(adapter, configured) {
+    if (configured.type === 'entity') return [configured.id];
+    return labelLights(configured.id, await adapter.registries());
+}
+function createTargetResolver(adapter) {
+    let snapshot;
+    const membership = new Map();
+    return async selected => {
+        if (selected.type === 'entity') return [selected.id];
+        const next = await adapter.registries();
+        if (next !== snapshot) { membership.clear(); snapshot = next; }
+        if (!membership.has(selected.id)) membership.set(selected.id, labelLights(selected.id, snapshot));
+        return [...membership.get(selected.id)];
+    };
+}
+function aggregateStatus(infos) {
+    const counts = { on: 0, manual: 0, off: 0, unavailable: 0 };
+    for (const info of infos) {
+        if (!['on', 'off'].includes(info.state)) counts.unavailable++;
+        else if (info.manual_override) counts.manual++;
+        else counts[info.state]++;
+    }
+    return { fill: counts.unavailable ? 'red' : counts.manual ? 'yellow' : counts.on ? 'green' : 'grey',
+        shape: counts.unavailable ? 'ring' : 'dot',
+        text: infos.length ? Object.entries(counts).filter(([,n]) => n).map(([key,n]) => `${n} ${key}`).join(' · ') : 'LABEL EMPTY' };
+}
+module.exports = { target, labelLights, resolveTarget, createTargetResolver, aggregateStatus };

package/nodes/sw-light.html

@@ -13,6 +13,10 @@
             return true;
         };
     }
+    function targetKind(node) {
+        const field = typeof $ === 'function' ? $('#node-input-targetType') : null;
+        return field?.length ? field.val() || node.targetType || 'entity' : node.targetType || 'entity';
+    }
     RED.nodes.registerType('sw-light', {
         category: 'home assistant', color: '#c7d7e8', icon: 'font-awesome/fa-lightbulb-o',
         inputs: 1, outputs: 2, outputLabels: ['result / state', 'events / errors'],
@@ -20,64 +24,92 @@
         defaults: {
             name: { value: '' }, server: { value: '', type: 'server', required: true },
             action: { value: 'msg', validate: v => ['on','off','toggle','msg'].includes(v) },
-            entityId: { value: '', required: true, validate: v => /^light\.[a-z0-9_]+$/.test(v) },
+            targetType: { value: 'entity', validate: v => ['entity','label'].includes(v) },
+            entityId: { value: '', validate: function (v) { return targetKind(this) === 'label' || /^light\.[a-z0-9_]+$/.test(v); } },
+            labelId: { value: '', validate: function (v) { return targetKind(this) !== 'label' || (typeof v === 'string' && v.trim().length > 0); } },
             brightnessPct: { value: 94, validate: numeric('brightnessPct') },
             autoMaxPct: { value: 94, validate: numeric('autoMaxPct') },
             minPct: { value: 1, validate: numeric('minPct') },
             transitionOn: { value: 1, validate: numeric('transitionOn') },
             transitionOff: { value: 1, validate: numeric('transitionOff') },
-            manualOverride: { value: true }, overrideThreshold: { value: 100, validate: numeric('overrideThreshold') },
-            overrideStrategy: { value: 'threshold' }, colorMode: { value: 'adaptive' },
+            manualOverride: { value: true }, overrideThreshold: { value: 98, validate: numeric('overrideThreshold') },
+            overrideStrategy: { value: 'threshold' }, colorMode: { value: 'keep' },
+            adaptiveEnabled: { value: false },
             kelvin: { value: 2700, validate: numeric('kelvin') }, mired: { value: 370, validate: numeric('mired') },
             fixedColor: { value: '#ffffff', validate: v => /^#[0-9a-f]{6}$/i.test(v) },
             adaptiveEntity: { value: '', validate: v => !v || /^switch\.[a-z0-9_]+$/.test(v) },
-            adaptiveDiscover: { value: true }, adaptiveApply: { value: false }, adaptiveRespectManual: { value: true }
         },
         oneditprepare: function () {
-            let states = {}, request, generation = 0;
+            if (this.colorMode === 'adaptive') {
+                $('#node-input-colorMode').val('keep');
+                $('#node-input-adaptiveEnabled').prop('checked', this.adaptiveApply === true);
+            }
+            let states = {}, labels = [], request, labelRequest, generation = 0;
+            $('#node-input-targetType').val(this.targetType || 'entity');
+            const label = $('#node-input-labelId');
             const entity = $('#node-input-entityId'), adaptive = $('#node-input-adaptiveEntity');
+            function modesForLight() { return states[entity.val()]?.attributes?.supported_color_modes || []; }
             function update() {
+                const isLabel = $('#node-input-targetType').val() === 'label';
+                $('.sw-entity-target').toggle(!isLabel); $('.sw-label-target').toggle(isLabel);
+                $('#sw-label-name').text(labels.find(l => l.label_id === label.val())?.name || 'Select a Label or enter its stable ID.');
                 const mode = $('#node-input-colorMode').val();
                 $('.sw-color-row').hide();
                 $('.sw-color-' + mode).show();
+                $('.sw-adaptive-row').toggle($('#node-input-adaptiveEnabled').prop('checked'));
+                const profiles = Object.values(states).filter(s => s.entity_id.startsWith('switch.') &&
+                    Array.isArray(s.attributes?.configuration?.lights) && s.attributes.configuration.lights.includes(entity.val()));
+                $('#sw-adaptive-info').text(isLabel ? 'A unique profile is discovered per light. Advanced selects one shared fallback; keep its main switch off.' : modesForLight().includes('color_temp') ?
+                    (profiles.length === 1 ? 'Profile found. Keep its main switch off for one-shot use.' :
+                        'No unique profile found. Select a profile under Advanced.') : 'This light has no known color-temperature support. Normal ON still works.');
                 $('.sw-override-row').toggle($('#node-input-manualOverride').prop('checked'));
                 $('.sw-threshold-row').toggle($('#node-input-manualOverride').prop('checked') && $('#node-input-overrideStrategy').val() === 'threshold');
                 const s = states[entity.val()], modes = s && s.attributes && s.attributes.supported_color_modes;
-                $('#sw-capabilities').text(modes ? 'Supported: ' + modes.join(', ') : 'Select a deployed server and light to read capabilities.');
+                $('#sw-capabilities').text(isLabel ? 'Capabilities and Adaptive Lighting profiles are evaluated per resolved light.' : modes ? 'Supported: ' + modes.join(', ') : 'Select a deployed server and light to read capabilities.');
                 // Disabled options reflect known capabilities, without discarding saved settings.
-                $('#node-input-colorMode option[value="kelvin"], #node-input-colorMode option[value="mired"]').prop('disabled', !!modes && !modes.includes('color_temp'));
-                $('#node-input-colorMode option[value="color"]').prop('disabled', !!modes && !modes.some(m => ['hs','xy','rgb','rgbw','rgbww'].includes(m)));
+                $('#node-input-colorMode option[value="kelvin"], #node-input-colorMode option[value="mired"]').prop('disabled', !isLabel && !!modes && !modes.includes('color_temp'));
+                $('#node-input-colorMode option[value="color"]').prop('disabled', !isLabel && !!modes && !modes.some(m => ['hs','xy','rgb','rgbw','rgbww'].includes(m)));
             }
             function source(domain) {
                 return function (req, respond) {
                     const term = req.term.toLowerCase();
                     respond(Object.values(states).filter(s => s.entity_id.startsWith(domain + '.') &&
+                        (domain !== 'switch' || s.attributes?.configuration) &&
                         (s.entity_id.toLowerCase().includes(term) || String(s.attributes.friendly_name || '').toLowerCase().includes(term)))
                         .slice(0,100).map(s => ({ label: (s.attributes.friendly_name || s.entity_id) + ' (' + s.entity_id + ')', value: s.entity_id })));
                 };
             }
             entity.autocomplete({ minLength: 0, source: source('light'), select: function (_e, ui) { entity.val(ui.item.value); update(); } });
+            label.autocomplete({ minLength: 0, source: function (req, respond) {
+                const term = req.term.toLowerCase();
+                respond(labels.filter(l => l.label_id.toLowerCase().includes(term) || l.name.toLowerCase().includes(term))
+                    .map(l => ({ label: l.name + ' (' + l.label_id + ')', value: l.label_id })));
+            }, select: function (_e, ui) { label.val(ui.item.value); update(); } });
+            label.on('focus.swLight', function () { label.autocomplete('search', label.val()); });
             adaptive.autocomplete({ minLength: 0, source: source('switch') });
             function load() {
                 generation++; const token = generation;
-                if (request) request.abort();
-                states = {}; update();
+                if (request) request.abort(); if (labelRequest) labelRequest.abort();
+                states = {}; labels = []; update();
                 const server = $('#node-input-server').val();
                 if (!server || server === '_ADD_') return;
                 $('#sw-capabilities').text('Loading Home Assistant entities…');
-                // HA contrib's own editor endpoint. No auth tokens or static entity lists.
+                // Label route uses the shared adapter; Entity route belongs to HA contrib.
+                labelRequest = $.getJSON('sw-light/labels/' + encodeURIComponent(server))
+                    .done(function (data) { if (token === generation) { labels = Array.isArray(data) ? data : []; update(); } })
+                    .fail(function (_xhr, status) { if (status !== 'abort' && token === generation) $('#sw-label-name').text('Server must be deployed and connected. A stable Label ID can also be entered directly.'); });
                 request = $.getJSON('homeassistant/states/' + encodeURIComponent(server))
                     .done(function (data) { if (token === generation) { states = data || {}; update(); } })
                     .fail(function (_xhr, status) { if (status !== 'abort' && token === generation) $('#sw-capabilities').text('Server must be deployed and connected. Entity IDs can also be entered directly.'); });
             }
             $('#node-input-server').on('change.swLight', load);
-            $('#node-input-colorMode, #node-input-manualOverride, #node-input-overrideStrategy, #node-input-entityId').on('change.swLight', update);
+            $('#node-input-targetType, #node-input-labelId, #node-input-colorMode, #node-input-adaptiveEnabled, #node-input-manualOverride, #node-input-overrideStrategy, #node-input-entityId').on('change.swLight', update);
             entity.on('focus.swLight', function () { entity.autocomplete('search', entity.val()); });
             adaptive.on('focus.swLight', function () { adaptive.autocomplete('search', adaptive.val()); });
             this._swCleanup = function () {
-                generation++; if (request) request.abort();
-                $('#node-input-server, #node-input-colorMode, #node-input-manualOverride, #node-input-overrideStrategy, #node-input-entityId, #node-input-adaptiveEntity').off('.swLight');
-                entity.autocomplete('destroy'); adaptive.autocomplete('destroy');
+                generation++; if (request) request.abort(); if (labelRequest) labelRequest.abort();
+                $('#node-input-server, #node-input-targetType, #node-input-labelId, #node-input-colorMode, #node-input-adaptiveEnabled, #node-input-manualOverride, #node-input-overrideStrategy, #node-input-entityId, #node-input-adaptiveEntity').off('.swLight');
+                label.autocomplete('destroy'); label.off('.swLight'); entity.autocomplete('destroy'); adaptive.autocomplete('destroy');
                 delete this._swCleanup;
             };
             load(); update();
@@ -91,7 +123,9 @@
 <script type="text/html" data-template-name="sw-light">
     <div class="form-row"><label for="node-input-name"><i class="fa fa-tag"></i> Name</label><input id="node-input-name" type="text" placeholder="SW Light"></div>
     <div class="form-row"><label for="node-input-server"><i class="fa fa-server"></i> HA server</label><input id="node-input-server" type="text"></div>
-    <div class="form-row"><label for="node-input-entityId"><i class="fa fa-lightbulb-o"></i> Light</label><input id="node-input-entityId" type="text" placeholder="light.entity_id"></div>
+    <div class="form-row"><label for="node-input-targetType">Target</label><select id="node-input-targetType"><option value="entity">Entity</option><option value="label">Label</option></select></div>
+    <div class="form-row sw-label-target"><label for="node-input-labelId">Label</label><input id="node-input-labelId" type="text" placeholder="Stable Label ID"><p id="sw-label-name"></p></div>
+    <div class="form-row sw-entity-target"><label for="node-input-entityId"><i class="fa fa-lightbulb-o"></i> Light</label><input id="node-input-entityId" type="text" placeholder="light.entity_id"></div>
     <div class="form-row"><label for="node-input-action">Action</label><select id="node-input-action"><option value="on">On</option><option value="off">Off</option><option value="toggle">Toggle</option><option value="msg">From msg</option></select></div>
     <div class="form-tips" id="sw-capabilities" style="margin-bottom:16px"></div>
     <fieldset><legend>Automatic lighting</legend>
@@ -108,25 +142,27 @@
         <p class="sw-override-row">Automatic commands pause during override. Manual commands use <code>msg.source = "manual"</code>.</p>
     </fieldset>
     <fieldset><legend>Color</legend>
-        <div class="form-row"><label for="node-input-colorMode">Mode</label><select id="node-input-colorMode"><option value="adaptive">Adaptive Lighting</option><option value="keep">Keep current</option><option value="kelvin">Fixed Kelvin</option><option value="mired">Fixed mired</option><option value="default">Lamp default</option><option value="color">Fixed color</option></select></div>
+        <div class="form-row"><label for="node-input-colorMode">Mode</label><select id="node-input-colorMode"><option value="keep">Keep current</option><option value="kelvin">Fixed Kelvin</option><option value="mired">Fixed mired</option><option value="default">Lamp default</option><option value="color">Fixed color</option></select></div>
         <div class="form-row sw-color-row sw-color-kelvin"><label for="node-input-kelvin">Kelvin</label><input id="node-input-kelvin" type="number" min="1000" max="40000"></div>
         <div class="form-row sw-color-row sw-color-mired"><label for="node-input-mired">Mired</label><input id="node-input-mired" type="number" min="25" max="1000" step="0.1"></div>
         <div class="form-row sw-color-row sw-color-color"><label for="node-input-fixedColor">Color</label><input id="node-input-fixedColor" type="color"></div>
-        <div class="form-row sw-color-row sw-color-adaptive"><label for="node-input-adaptiveEntity">Adaptive switch</label><input id="node-input-adaptiveEntity" type="text" placeholder="Optional switch.entity_id"></div>
-        <div class="form-row sw-color-row sw-color-adaptive"><label for="node-input-adaptiveDiscover">Discover</label><input id="node-input-adaptiveDiscover" type="checkbox" style="width:auto"> From a unique light membership match</div>
-        <div class="form-row sw-color-row sw-color-adaptive"><label for="node-input-adaptiveApply">Apply on turn-on</label><input id="node-input-adaptiveApply" type="checkbox" style="width:auto"> Color only</div>
-        <div class="form-row sw-color-row sw-color-adaptive"><label for="node-input-adaptiveRespectManual">Respect manual</label><input id="node-input-adaptiveRespectManual" type="checkbox" style="width:auto"></div>
-        <p class="sw-color-row sw-color-adaptive">Ordinary turn-on sends no color. Adaptive Lighting owns color adaptation. Apply is optional and never clears its manual control.</p>
+        <div class="form-row"><label for="node-input-adaptiveEnabled">Adaptive Lighting</label><input id="node-input-adaptiveEnabled" type="checkbox" style="width:auto"> On / Off</div>
+        <p class="sw-adaptive-row" id="sw-adaptive-info"></p>
+        <details class="sw-adaptive-row"><summary>Advanced: profile selection</summary>
+            <div class="form-row"><label for="node-input-adaptiveEntity">Profile</label><input id="node-input-adaptiveEntity" type="text" placeholder="Automatic (unique light membership)"></div>
+            <p>Select only when automatic discovery is unavailable or ambiguous. The profile's main switch must be off.</p>
+        </details>
     </fieldset>
 </script>
 
 <script type="text/html" data-help-name="sw-light">
-    <p>Controls one Home Assistant light directly: Trigger → SW Light → Home Assistant. No downstream HA Action node is required. Select On, Off, Toggle, or From msg. Toggle resolves the current state to turn_on or turn_off.</p>
+    <p>Controls a Home Assistant Entity or Label directly: Trigger → SW Light → Home Assistant. No downstream HA Action node is required. Select On, Off, Toggle, or From msg. Toggle resolves the current state to turn_on or turn_off.</p>
+    <p>Entity is the default for existing flows. Label stores its stable ID and resolves current light members, including labeled devices and labeled area relationships. Each light retains its own override and capabilities. Label output 1 contains target, resolved_entity_ids, results and counts; status summarizes observed states. A failed member does not stop others. <code>msg.target = {type: "label", id: "label_id"}</code> or <code>{type: "entity", id: "light.example"}</code> overrides the configured target for one input. The latest target is observed until the next input.</p>
     <h3>Inputs</h3>
     <dl class="message-properties"><dt>action <span class="property-type">string</span></dt><dd>Required with From msg: <code>on</code>, <code>off</code>, or <code>toggle</code>. Falls back to <code>msg.auto_light.action</code> when msg.action is absent. Fixed Action settings ignore message actions.</dd><dt class="optional">source <span class="property-type">string</span></dt><dd><code>automatic</code> (default) or <code>manual</code>.</dd><dt class="optional">brightness_pct <span class="property-type">number</span></dt><dd>0–100. Automatic brightness is capped at the configured maximum.</dd><dt class="optional">transition <span class="property-type">number</span></dt><dd>Fade seconds, 0–3600, if supported.</dd><dt class="optional">manual_override <span class="property-type">boolean</span></dt><dd>Latch/release override with <code>source: "manual"</code>.</dd></dl>
     <h3>Outputs</h3><ol><li>Original message plus <code>msg.sw_light</code>: last observed HA state, action, service data, and override/adaptive information.</li><li>Original message plus <code>msg.sw_light_event</code>: version, type, entity_id, timestamp, and details.</li></ol>
-    <h3>Details</h3><p>Default on brightness/max 94%, minimum 1%, fade 1s. ON at 100% (brightness 255) always blocks automatic ON, OFF and Toggle. 94%, 95% and 99% do not trigger this guard. Optional threshold/explicit overrides can also pause automation. Lowering brightness below the threshold releases its flag; turning off releases all override flags. Manual commands bypass the automatic maximum. Explicit flags require explicit release or off.</p>
+    <h3>Details</h3><p>Default on brightness/max 94%, minimum 1%, fade 1s. ON at 100% (brightness 255) always blocks automatic ON, OFF and Toggle. 94%, 95% and 99% do not trigger this guard. Threshold detection defaults to 98% (brightness 250 or above) and pauses automatic commands; explicit overrides can also pause automation. Lowering brightness below the threshold releases its flag; turning off releases all override flags. Manual commands bypass the automatic maximum. Explicit flags require explicit release or off.</p>
     <p>Top-level message properties override configuration. Brightness precedence: percent, byte, percent step, byte step. Color precedence: Kelvin, mired, RGBWW, RGBW, RGB, HS, XY, name. Invalid values produce errors; unsupported parameters emit an event and are omitted.</p>
-    <p>Adaptive mode sends no configured color. An explicit message color takes precedence and suppresses optional adaptive apply for that command. Keep current and lamp default both omit configured color and leave HA/device behavior in control.</p>
+    <p>Adaptive Lighting applies current color temperature once after automatic OFF → ON, with SW Light brightness and fade. Explicit message color wins; already-on brightness changes and manual commands never apply it. A unique profile is discovered automatically; Advanced selects a fallback. Keep its main switch off to prevent continuous control. Use a profile with color-temperature sleep color; RGB sleep profiles fall back with a warning. <code>msg.adaptive_lighting</code> overrides the checkbox for one command. Missing, ambiguous or running profiles emit a warning and retain normal configured color behavior. Keep current and lamp default both omit configured color and leave HA/device behavior in control.</p>
     <p>Requires HA contrib 0.80.3. See package README for full contracts, examples and compatibility limitations.</p>
 </script>