fix(clg-collection): run member fanout in background to avoid 10s timeout

Homey enforces a 10 s budget on capability listeners. The Collection's
inherited onoff listener awaited a full fanout that, on flaky Z-Wave or
Zigbee lamps, can spend 20-30 s in retry/verify. Result: a red
"Timeout after 10000ms" toast on every toggle even though most lamps
respond fine. Drop the fanout into the background; surface failures via
alarm_config and a triggerError that names which member groups had
unresponsive lamps. Same pattern for the other long-running flow handlers
(turn_on/off, pause/resume, apply_state, set_external_lux,
set_red_threshold, force_red_mode).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Tiwas

no.tiwas.booleantoolbox/.homeychangelog.json

@@ -88,5 +88,8 @@
   },
   "1.10.13": {
     "en": "Fix: Toggling a Circadian Light Group Collection now flips each member group's own on/off state (not only the underlying lamps), so the member tiles update as expected."
+  },
+  "1.10.14": {
+    "en": "Fix: Circadian Light Group Collection no longer shows a 'Timeout after 10000ms' toast when a single lamp inside a member group is unresponsive. Member fanout now runs in the background, and the timeline error names which groups had unresponsive members."
   }
 }

no.tiwas.booleantoolbox/drivers/circadian-light-group-collection/device.js

@@ -99,11 +99,21 @@ class CircadianLightGroupCollectionDevice extends CircadianLightGroupDevice {
     const failed = result.failed || [];
     await this.setCapabilityValue('alarm_config', failed.length > 0).catch(this.error);
     if (failed.length > 0) {
-      await this.triggerError(`${failed.length} Circadian Light Group member(s) failed during ${label}`);
+      const names = failed.map(e => e.name || e.id).join(', ');
+      await this.triggerError(`${label}: ${failed.length} group(s) had unresponsive members: ${names}`);
     }
     return result;
   }
 
+  fanoutInBackground(label, taskFn, verifyFn = null) {
+    // Capability listeners and several Flow actions must return within Homey's 10 s
+    // budget — but lamps behind a member group can take 20-30 s on retries. Drop the
+    // fanout into the background; failures surface via alarm_config + triggerError.
+    this.runForMemberGroups(label, taskFn, verifyFn).catch(err => {
+      this.error(`Collection background fanout '${label}' failed:`, err);
+    });
+  }
+
   async applyCurrentProfile({ reason = 'manual' } = {}) {
     if (this.deleted) return false;
     const result = await this.runForMemberGroups(`apply_${reason}`, async (device) => {
@@ -130,15 +140,15 @@ class CircadianLightGroupCollectionDevice extends CircadianLightGroupDevice {
 
   async onFlowTurnOn() {
     await this.setCollectionOnoff(true);
-    await this.runForMemberGroups('turn_on', async (device) => {
+    this.fanoutInBackground('turn_on', async (device) => {
       await device.onFlowTurnOn();
     }, async (device) => device.getCapabilityValue('onoff') === true);
     return true;
   }
 
   async onFlowTurnOff() {
     await this.setCollectionOnoff(false);
-    await this.runForMemberGroups('turn_off', async (device) => {
+    this.fanoutInBackground('turn_off', async (device) => {
       await device.onFlowTurnOff();
     }, async (device) => device.getCapabilityValue('onoff') === false);
     return true;
@@ -164,59 +174,60 @@ class CircadianLightGroupCollectionDevice extends CircadianLightGroupDevice {
 
   async onFlowTurnOnAllMembers() {
     // For a Collection, "all members" = the member CLG devices themselves.
-    // Use onFlowTurnOn so each member's onoff capability flips and its lights follow.
-    await this.runForMemberGroups('turn_on_all_members', async (device) => {
+    // Fire-and-forget so the caller (capability listener or Flow action) returns within
+    // Homey's 10 s budget even when an underlying lamp doesn't respond.
+    this.fanoutInBackground('turn_on_all_members', async (device) => {
       await device.onFlowTurnOn();
     }, async (device) => device.getCapabilityValue('onoff') === true);
     return true;
   }
 
   async onFlowTurnOffAllMembers() {
-    await this.runForMemberGroups('turn_off_all_members', async (device) => {
+    this.fanoutInBackground('turn_off_all_members', async (device) => {
       await device.onFlowTurnOff();
     }, async (device) => device.getCapabilityValue('onoff') === false);
     return true;
   }
 
   async onFlowPause(args) {
     await super.onFlowPause(args);
-    await this.runForMemberGroups('pause', async (device) => {
+    this.fanoutInBackground('pause', async (device) => {
       await device.onFlowPause(args);
     }, async (device) => device.getCapabilityValue('clg_paused') === true);
     return true;
   }
 
   async onFlowResume() {
-    await this.runForMemberGroups('resume', async (device) => {
+    this.fanoutInBackground('resume', async (device) => {
       await device.onFlowResume();
     }, async (device) => device.getCapabilityValue('clg_paused') !== true);
     await super.onFlowResume();
     return true;
   }
 
   async onFlowSetExternalLux(args) {
-    await this.runForMemberGroups('set_external_lux', async (device) => {
+    this.fanoutInBackground('set_external_lux', async (device) => {
       await device.onFlowSetExternalLux(args);
     });
     return true;
   }
 
   async onFlowSetRedThreshold(args) {
-    await this.runForMemberGroups('set_red_threshold', async (device) => {
+    this.fanoutInBackground('set_red_threshold', async (device) => {
       await device.onFlowSetRedThreshold(args);
     });
     return true;
   }
 
   async onFlowApplyState(args) {
-    await this.runForMemberGroups('apply_state', async (device) => {
+    this.fanoutInBackground('apply_state', async (device) => {
       await device.onFlowApplyState(args);
     });
     return true;
   }
 
   async onFlowForceRedMode(args) {
-    await this.runForMemberGroups('force_red_mode', async (device) => {
+    this.fanoutInBackground('force_red_mode', async (device) => {
       await device.onFlowForceRedMode(args);
     });
     return true;