homebridge-lovesac-stealthtech 1.0.2 → 1.1.1

package/config.schema.json

@@ -10,6 +10,7 @@
       "devices": {
         "title": "Devices",
         "type": "array",
+        "maxItems": 1,
         "items": {
           "type": "object",
           "properties": {

package/dist/accessory.d.ts

@@ -14,6 +14,7 @@ export declare class LovesacAccessory {
     private readonly presetSwitches;
     private quietModeService;
     private volumeDebounceTimer;
+    private volumeDebounceResolve;
     private readonly Characteristic;
     constructor(platform: LovesacPlatform, accessory: PlatformAccessory, config: LovesacDeviceConfig, device: LovesacDevice);
     private setPower;
@@ -23,6 +24,7 @@ export declare class LovesacAccessory {
     private setVolumeSelector;
     private setVolumeOn;
     private setVolumePercent;
+    shutdown(): void;
     /**
      * Workaround for tvOS 18+ Home Hub bug (homebridge/homebridge#3703).
      * The Home Hub forcibly renames services to localized generic defaults
@@ -32,5 +34,6 @@ export declare class LovesacAccessory {
     private setupConfiguredNameHandler;
     private cyclePreset;
     private updatePresetSwitches;
+    private handleUnreachable;
     private handleStateChange;
 }

package/dist/accessory.js

@@ -16,6 +16,7 @@ class LovesacAccessory {
     presetSwitches = [];
     quietModeService = null;
     volumeDebounceTimer = null;
+    volumeDebounceResolve = null;
     Characteristic;
     constructor(platform, accessory, config, device) {
         this.platform = platform;
@@ -48,7 +49,9 @@ class LovesacAccessory {
         // See: https://github.com/homebridge/homebridge/issues/3703
         this.tvService = this.accessory.addService(Service.Television, this.config.name, 'television');
         this.tvService.setPrimaryService(true);
-        this.tvService.setCharacteristic(this.Characteristic.SleepDiscoveryMode, this.Characteristic.SleepDiscoveryMode.ALWAYS_DISCOVERABLE);
+        this.tvService
+            .setCharacteristic(this.Characteristic.Active, this.Characteristic.Active.INACTIVE)
+            .setCharacteristic(this.Characteristic.SleepDiscoveryMode, this.Characteristic.SleepDiscoveryMode.ALWAYS_DISCOVERABLE);
         // Use setValue() for ConfiguredName and Name to ensure proper HAP notification
         this.tvService.getCharacteristic(this.Characteristic.ConfiguredName).setValue(this.config.name);
         this.tvService.getCharacteristic(this.Characteristic.Name).setValue(this.config.name);
@@ -56,10 +59,24 @@ class LovesacAccessory {
         this.setupConfiguredNameHandler(this.tvService, this.config.name);
         // Active (power)
         this.tvService.getCharacteristic(this.Characteristic.Active)
-            .onSet(this.setPower.bind(this));
+            .onSet(this.setPower.bind(this))
+            .onGet(() => {
+            if (!this.device.isStateInitialized()) {
+                throw new hap_nodejs_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+            }
+            return this.device.state.power
+                ? this.Characteristic.Active.ACTIVE
+                : this.Characteristic.Active.INACTIVE;
+        });
         // ActiveIdentifier (input source)
         this.tvService.getCharacteristic(this.Characteristic.ActiveIdentifier)
-            .onSet(this.setActiveIdentifier.bind(this));
+            .onSet(this.setActiveIdentifier.bind(this))
+            .onGet(() => {
+            if (!this.device.isStateInitialized()) {
+                throw new hap_nodejs_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+            }
+            return this.device.state.source + 1;
+        });
         // Remote key
         this.tvService.getCharacteristic(this.Characteristic.RemoteKey)
             .onSet(this.setRemoteKey.bind(this));
@@ -94,7 +111,13 @@ class LovesacAccessory {
         this.speakerService
             .setCharacteristic(this.Characteristic.VolumeControlType, this.Characteristic.VolumeControlType.RELATIVE_WITH_CURRENT);
         this.speakerService.getCharacteristic(this.Characteristic.Mute)
-            .onSet(this.setMute.bind(this));
+            .onSet(this.setMute.bind(this))
+            .onGet(() => {
+            if (!this.device.isStateInitialized()) {
+                throw new hap_nodejs_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+            }
+            return this.device.state.mute;
+        });
         this.speakerService.getCharacteristic(this.Characteristic.VolumeSelector)
             .onSet(this.setVolumeSelector.bind(this));
         this.tvService.addLinkedService(this.speakerService);
@@ -131,7 +154,15 @@ class LovesacAccessory {
             switchService.getCharacteristic(this.Characteristic.On)
                 .onSet(async (value) => {
                 if (!value) {
-                    return; // Turning off is a no-op — can't unselect a preset
+                    // Can't unselect a preset — push back the real state
+                    this.updatePresetSwitches(this.device.state.preset);
+                    return;
+                }
+                if (!this.device.state.power) {
+                    // Device is off — reject and push back current state
+                    this.platform.log.info('Preset change ignored — device is off');
+                    this.updatePresetSwitches(this.device.state.preset);
+                    return;
                 }
                 try {
                     await this.device.setPreset(preset.writeVal);
@@ -155,6 +186,13 @@ class LovesacAccessory {
         this.setupConfiguredNameHandler(this.quietModeService, 'Quiet Mode');
         this.quietModeService.getCharacteristic(this.Characteristic.On)
             .onSet(async (value) => {
+            if (!this.device.state.power) {
+                this.platform.log.info('Quiet mode change ignored — device is off');
+                setTimeout(() => {
+                    this.quietModeService.getCharacteristic(this.Characteristic.On).updateValue(false);
+                }, 0);
+                return;
+            }
             try {
                 await this.device.setQuietMode(value);
             }
@@ -165,6 +203,7 @@ class LovesacAccessory {
         });
         // --- Listen for device state changes ---
         this.device.onStateChange(this.handleStateChange.bind(this));
+        this.device.onUnreachable(this.handleUnreachable.bind(this));
         // Start background polling (also triggers initial state fetch via onReconnect)
         this.device.startPolling(this.config.pollInterval);
     }
@@ -182,6 +221,14 @@ class LovesacAccessory {
     // --- Input Source ---
     // HomeKit Identifier 1-4 maps to SourceValue 0-3
     async setActiveIdentifier(value) {
+        if (!this.device.state.power) {
+            this.platform.log.info('Source change ignored — device is off');
+            setTimeout(() => {
+                this.tvService.getCharacteristic(this.Characteristic.ActiveIdentifier)
+                    .updateValue(this.device.state.source + 1);
+            }, 0);
+            return;
+        }
         try {
             const source = value - 1;
             await this.device.setSource(source);
@@ -193,6 +240,10 @@ class LovesacAccessory {
     }
     // --- Remote Key ---
     async setRemoteKey(value) {
+        if (!this.device.state.power) {
+            this.platform.log.info('Remote key ignored — device is off');
+            return;
+        }
         try {
             const RemoteKey = this.Characteristic.RemoteKey;
             switch (value) {
@@ -218,6 +269,10 @@ class LovesacAccessory {
     }
     // --- Mute ---
     async setMute(value) {
+        if (!this.device.state.power) {
+            this.platform.log.info('Mute change ignored — device is off');
+            return;
+        }
         try {
             await this.device.setMute(value);
         }
@@ -228,6 +283,10 @@ class LovesacAccessory {
     }
     // --- Volume Selector (up/down buttons in Control Center remote) ---
     async setVolumeSelector(value) {
+        if (!this.device.state.power) {
+            this.platform.log.info('Volume selector ignored — device is off');
+            return;
+        }
         try {
             if (value === this.Characteristic.VolumeSelector.INCREMENT) {
                 await this.device.volumeUp(this.config.volumeStep);
@@ -243,25 +302,73 @@ class LovesacAccessory {
     }
     // --- Volume Proxy (Fan/Lightbulb) ---
     async setVolumeOn(value) {
-        if (!value) {
-            await this.device.setMute(true);
+        if (!this.device.state.power) {
+            this.platform.log.info('Volume on/off ignored — device is off');
+            if (this.volumeService) {
+                setTimeout(() => {
+                    this.volumeService.getCharacteristic(this.Characteristic.On).updateValue(false);
+                }, 0);
+            }
+            return;
+        }
+        try {
+            if (!value) {
+                await this.device.setMute(true);
+            }
+            else {
+                if (this.device.state.mute) {
+                    await this.device.setMute(false);
+                }
+                if (this.device.state.volume <= 0) {
+                    await this.device.setVolume(this.config.volumeStep);
+                }
+            }
         }
-        else if (this.device.state.mute) {
-            await this.device.setMute(false);
+        catch (err) {
+            this.platform.log.error('setVolumeOn failed: %s', (0, settings_1.errorMessage)(err));
+            throw new hap_nodejs_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
         }
     }
-    setVolumePercent(value) {
+    async setVolumePercent(value) {
+        if (!this.device.state.power) {
+            this.platform.log.info('Volume change ignored — device is off');
+            if (this.volumeService) {
+                const levelChar = this.config.volumeControl === 'fan'
+                    ? this.Characteristic.RotationSpeed : this.Characteristic.Brightness;
+                const currentPercent = this.device.volumeToPercent(this.device.state.volume);
+                setTimeout(() => {
+                    this.volumeService.getCharacteristic(levelChar).updateValue(currentPercent);
+                }, 0);
+            }
+            return;
+        }
         const percent = value;
-        // Debounce: HomeKit slider sends many rapid updates
+        // Debounce: HomeKit slider sends many rapid updates.
+        // Superseded calls resolve immediately (their value was never sent).
         if (this.volumeDebounceTimer) {
             clearTimeout(this.volumeDebounceTimer);
+            this.volumeDebounceResolve?.();
+        }
+        return new Promise((resolve, reject) => {
+            this.volumeDebounceResolve = resolve;
+            this.volumeDebounceTimer = setTimeout(() => {
+                this.volumeDebounceTimer = null;
+                this.volumeDebounceResolve = null;
+                const volume = this.device.percentToVolume(percent);
+                this.device.setVolume(volume).then(resolve, (err) => {
+                    this.platform.log.error('Failed to set volume: %s', (0, settings_1.errorMessage)(err));
+                    reject(new hap_nodejs_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */));
+                });
+            }, 100);
+        });
+    }
+    shutdown() {
+        if (this.volumeDebounceTimer) {
+            clearTimeout(this.volumeDebounceTimer);
+            this.volumeDebounceTimer = null;
+            this.volumeDebounceResolve?.();
+            this.volumeDebounceResolve = null;
         }
-        this.volumeDebounceTimer = setTimeout(() => {
-            const volume = this.device.percentToVolume(percent);
-            this.device.setVolume(volume).catch((err) => {
-                this.platform.log.error('Failed to set volume: %s', (0, settings_1.errorMessage)(err));
-            });
-        }, 100);
     }
     // --- Helpers ---
     /**
@@ -306,6 +413,24 @@ class LovesacAccessory {
                 .updateValue(ps.presetRead === activePreset);
         }
     }
+    // --- Unreachable Handler ---
+    handleUnreachable() {
+        this.platform.log.warn('Device unreachable — updating HomeKit to show inactive');
+        this.tvService.getCharacteristic(this.Characteristic.Active)
+            .updateValue(this.Characteristic.Active.INACTIVE);
+        if (this.volumeService) {
+            this.volumeService.getCharacteristic(this.Characteristic.On)
+                .updateValue(false);
+        }
+        for (const ps of this.presetSwitches) {
+            ps.service.getCharacteristic(this.Characteristic.On)
+                .updateValue(false);
+        }
+        if (this.quietModeService) {
+            this.quietModeService.getCharacteristic(this.Characteristic.On)
+                .updateValue(false);
+        }
+    }
     // --- State Change Handler ---
     handleStateChange(code, _value) {
         switch (code) {
@@ -314,6 +439,32 @@ class LovesacAccessory {
                     .updateValue(this.device.state.power
                     ? this.Characteristic.Active.ACTIVE
                     : this.Characteristic.Active.INACTIVE);
+                // Also refresh volume proxy — after unreachable recovery, Power may
+                // arrive before Volume/Mute, leaving the proxy stale at "Off".
+                if (this.volumeService) {
+                    this.volumeService.getCharacteristic(this.Characteristic.On)
+                        .updateValue(this.device.state.power && !this.device.state.mute && this.device.state.volume > 0);
+                }
+                if (this.device.state.power) {
+                    // Restore preset switches and quiet mode from cached state —
+                    // they were cleared when power went off, and the poll may not
+                    // re-fire those listeners if the values haven't changed.
+                    this.updatePresetSwitches(this.device.state.preset);
+                    if (this.quietModeService) {
+                        this.quietModeService.getCharacteristic(this.Characteristic.On)
+                            .updateValue(this.device.state.quietMode);
+                    }
+                }
+                else {
+                    // When powered off, clear preset switches and quiet mode so their
+                    // tiles don't misleadingly show "On" / "Powered On".
+                    for (const ps of this.presetSwitches) {
+                        ps.service.getCharacteristic(this.Characteristic.On).updateValue(false);
+                    }
+                    if (this.quietModeService) {
+                        this.quietModeService.getCharacteristic(this.Characteristic.On).updateValue(false);
+                    }
+                }
                 break;
             case constants_1.ResponseCode.Volume:
                 if (this.volumeService) {
@@ -322,7 +473,7 @@ class LovesacAccessory {
                         ? this.Characteristic.RotationSpeed : this.Characteristic.Brightness;
                     this.volumeService.getCharacteristic(levelChar).updateValue(percent);
                     this.volumeService.getCharacteristic(this.Characteristic.On)
-                        .updateValue(!this.device.state.mute && this.device.state.volume > 0);
+                        .updateValue(this.device.state.power && !this.device.state.mute && this.device.state.volume > 0);
                 }
                 break;
             case constants_1.ResponseCode.Mute:
@@ -330,7 +481,7 @@ class LovesacAccessory {
                     .updateValue(this.device.state.mute);
                 if (this.volumeService) {
                     this.volumeService.getCharacteristic(this.Characteristic.On)
-                        .updateValue(!this.device.state.mute && this.device.state.volume > 0);
+                        .updateValue(this.device.state.power && !this.device.state.mute && this.device.state.volume > 0);
                 }
                 break;
             case constants_1.ResponseCode.Source:
@@ -338,10 +489,12 @@ class LovesacAccessory {
                     .updateValue(this.device.state.source + 1);
                 break;
             case constants_1.ResponseCode.Preset:
-                this.updatePresetSwitches(this.device.state.preset);
+                if (this.device.state.power) {
+                    this.updatePresetSwitches(this.device.state.preset);
+                }
                 break;
             case constants_1.ResponseCode.QuietMode:
-                if (this.quietModeService) {
+                if (this.quietModeService && this.device.state.power) {
                     this.quietModeService.getCharacteristic(this.Characteristic.On)
                         .updateValue(this.device.state.quietMode);
                 }

package/dist/ble/BleClient.d.ts

@@ -15,6 +15,7 @@ export declare class BleClient implements IBleClient {
     private notificationHandler;
     private _connected;
     private _resolvedAddress;
+    private connectGeneration;
     constructor(log: Logger);
     get resolvedAddress(): string;
     connect(address?: string): Promise<void>;

package/dist/ble/BleClient.js

@@ -13,6 +13,7 @@ class BleClient {
     notificationHandler = null;
     _connected = false;
     _resolvedAddress = '';
+    connectGeneration = 0;
     constructor(log) {
         this.log = log;
     }
@@ -23,6 +24,7 @@ class BleClient {
         if (this._connected) {
             return;
         }
+        const gen = ++this.connectGeneration;
         let peripheral;
         if (address) {
             this.log.debug('BLE: Starting scan for %s...', address);
@@ -43,18 +45,35 @@ class BleClient {
             : peripheral.id ?? peripheral.uuid ?? 'unknown';
         this.log.debug('BLE: Connecting to %s...', resolvedId);
         this._resolvedAddress = resolvedId;
-        // Register disconnect handler BEFORE connecting to avoid race (P0-2)
+        // Register disconnect handler BEFORE connecting to avoid race (P0-2).
+        // Capture the generation so a stale handler from a timed-out attempt does
+        // not clear state that belongs to a newer connection.
         peripheral.once('disconnect', () => {
             this.log.debug('BLE: Disconnected');
-            this._connected = false;
-            this.peripheral = null;
-            this.characteristics = {};
+            if (gen === this.connectGeneration) {
+                this._connected = false;
+                this.peripheral = null;
+                this.characteristics = {};
+            }
         });
-        await peripheral.connectAsync();
+        try {
+            await (0, settings_1.withTimeout)(peripheral.connectAsync(), settings_1.BLE_CONNECT_TIMEOUT, 'BLE connect');
+        }
+        catch (err) {
+            peripheral.disconnectAsync().catch(() => { });
+            throw err;
+        }
         this._connected = true;
         this.peripheral = peripheral;
         this.log.debug('BLE: Discovering services and characteristics...');
-        const { characteristics } = await peripheral.discoverSomeServicesAndCharacteristicsAsync([settings_1.SOFA_SERVICE_UUID_SHORT], Object.values(settings_1.CharUUID));
+        let characteristics;
+        try {
+            ({ characteristics } = await (0, settings_1.withTimeout)(peripheral.discoverSomeServicesAndCharacteristicsAsync([settings_1.SOFA_SERVICE_UUID_SHORT], Object.values(settings_1.CharUUID)), settings_1.BLE_DISCOVER_TIMEOUT, 'BLE service discovery'));
+        }
+        catch (err) {
+            peripheral.disconnectAsync().catch(() => { });
+            throw err;
+        }
         for (const char of characteristics) {
             this.characteristics[char.uuid] = char;
         }
@@ -63,10 +82,10 @@ class BleClient {
     async disconnect() {
         if (this.peripheral && this._connected) {
             try {
-                await this.peripheral.disconnectAsync();
+                await (0, settings_1.withTimeout)(this.peripheral.disconnectAsync(), settings_1.BLE_DISCONNECT_TIMEOUT, 'BLE disconnect');
             }
             catch {
-                // Already disconnected
+                // Already disconnected or timed out — clean up regardless
             }
         }
         this._connected = false;
@@ -82,7 +101,7 @@ class BleClient {
             throw new Error(`Characteristic ${characteristicUuid} not found. Available: ${Object.keys(this.characteristics).join(', ')}`);
         }
         // Write without response (as per protocol spec)
-        await char.writeAsync(data, true);
+        await (0, settings_1.withTimeout)(char.writeAsync(data, true), settings_1.BLE_WRITE_TIMEOUT, 'BLE write');
     }
     async subscribeNotifications(handler) {
         this.notificationHandler = handler;
@@ -102,7 +121,7 @@ class BleClient {
                 }
             }
         });
-        await upstream.subscribeAsync();
+        await (0, settings_1.withTimeout)(upstream.subscribeAsync(), settings_1.BLE_DISCOVER_TIMEOUT, 'BLE subscribe');
         this.log.debug('BLE: Subscribed to UpStream notifications');
     }
     scanForAnyDevice() {

package/dist/ble/BleConnectionManager.js

@@ -34,7 +34,9 @@ class BleConnectionManager {
     async enqueue(command) {
         return new Promise((resolve, reject) => {
             this.queue.push({ command, resolve, reject });
-            this.processQueue();
+            this.processQueue().catch(err => {
+                this.log.error('processQueue error: %s', (0, settings_1.errorMessage)(err));
+            });
         });
     }
     async ensureConnected() {
@@ -123,16 +125,28 @@ class BleConnectionManager {
                     }
                     catch (retryErr) {
                         item.reject(retryErr);
+                        // Systemic failure — drain remaining queue to avoid N more
+                        // doomed reconnect attempts for N queued commands
+                        const remaining = this.queue.splice(0);
+                        for (const queued of remaining) {
+                            queued.reject(new Error('Queue drained after connection failure'));
+                        }
                     }
                 }
             }
         }
         finally {
             this.processing = false;
+            if (this.connected) {
+                this.resetIdleTimer();
+            }
         }
     }
     resetIdleTimer() {
         this.clearIdleTimer();
+        if (this.processing) {
+            return;
+        }
         this.idleTimer = setTimeout(() => {
             this.log.info('Idle timeout, disconnecting from %s', this.resolvedAddress);
             this.disconnect().catch((err) => {

package/dist/platform.js

@@ -22,6 +22,9 @@ class LovesacPlatform {
             this.discoverDevices();
         });
         this.api.on('shutdown', () => {
+            for (const acc of this.accessories) {
+                acc.shutdown();
+            }
             this.device?.stopPolling();
             this.connectionManager?.disconnect().catch(() => { });
         });
@@ -48,9 +51,12 @@ class LovesacPlatform {
         else {
             this.log.info('Setting up device: %s (auto-discovery)', deviceConfig.name);
         }
-        // Generate a stable UUID from the BLE address + plugin name
-        // _testSuffix in config allows generating a fresh identity for testing
-        // For auto-discovery, use a fixed seed so the identity is stable
+        // Generate a stable UUID from the BLE address + plugin name.
+        // _testSuffix in config allows generating a fresh identity for testing.
+        // For auto-discovery, use a fixed seed so the identity is stable.
+        // NOTE: Multiple Homebridge instances using auto-discovery on the same
+        // network will collide on this UUID. Configure an explicit BLE address
+        // in that scenario.
         const addressSeed = deviceConfig.address || 'auto';
         const uuidSeed = 'lovesac-st:' + addressSeed + (rawConfig._testSuffix ?? '');
         const uuid = this.api.hap.uuid.generate(uuidSeed);

package/dist/protocol/LovesacDevice.d.ts

@@ -3,21 +3,34 @@ import { BleConnectionManager } from '../ble/BleConnectionManager';
 import { DeviceState } from './responses';
 import { ResponseCode, PresetWriteValue, PresetReadValue, SourceValue } from './constants';
 export type StateChangeListener = (code: ResponseCode, value: number) => void;
+export type UnreachableListener = () => void;
 export declare class LovesacDevice {
     private readonly connectionManager;
     private readonly log;
     readonly state: DeviceState;
     private stateListeners;
+    private unreachableListeners;
     private stateInitialized;
+    private consecutiveFailures;
+    private reachable;
     mcuVersion: string;
     private versionListeners;
     private pollTimer;
+    private pollIntervalMs;
+    private basePollIntervalMs;
     constructor(connectionManager: BleConnectionManager, log: Logger);
     onStateChange(listener: StateChangeListener): void;
+    onUnreachable(listener: UnreachableListener): void;
     isStateInitialized(): boolean;
     onVersionResolved(callback: () => void): void;
     requestStateRefresh(): Promise<void>;
     startPolling(intervalSeconds: number): void;
+    private poll;
+    private schedulePoll;
+    private static readonly MAX_POLL_INTERVAL_MS;
+    private onPollSuccess;
+    private onPollFailure;
+    private markUnreachable;
     stopPolling(): void;
     getResolvedAddress(): string;
     setPower(on: boolean): Promise<void>;

package/dist/protocol/LovesacDevice.js

@@ -76,10 +76,15 @@ class LovesacDevice {
     log;
     state;
     stateListeners = [];
+    unreachableListeners = [];
     stateInitialized = false;
+    consecutiveFailures = 0;
+    reachable = true;
     mcuVersion = '';
     versionListeners = [];
     pollTimer = null;
+    pollIntervalMs = 0;
+    basePollIntervalMs = 0;
     constructor(connectionManager, log) {
         this.connectionManager = connectionManager;
         this.log = log;
@@ -87,15 +92,13 @@ class LovesacDevice {
         this.connectionManager.setNotificationHandler((data) => {
             this.handleNotification(data);
         });
-        this.connectionManager.onReconnect(() => {
-            this.requestStateRefresh().catch(err => {
-                this.log.warn('Reconnect state refresh failed: %s', (0, settings_1.errorMessage)(err));
-            });
-        });
     }
     onStateChange(listener) {
         this.stateListeners.push(listener);
     }
+    onUnreachable(listener) {
+        this.unreachableListeners.push(listener);
+    }
     isStateInitialized() {
         return this.stateInitialized;
     }
@@ -107,24 +110,71 @@ class LovesacDevice {
         await this.connectionManager.enqueue(commands.requestVersionInfo());
     }
     startPolling(intervalSeconds) {
+        if (this.pollTimer) {
+            return;
+        }
         if (intervalSeconds <= 0) {
             this.log.info('Background polling disabled');
             return;
         }
+        this.basePollIntervalMs = intervalSeconds * 1000;
+        this.pollIntervalMs = this.basePollIntervalMs;
         this.log.info('Starting background poll every %ds', intervalSeconds);
-        // Immediate initial fetch — onReconnect will also fire on first connect
-        this.requestStateRefresh().catch(err => {
-            this.log.warn('Initial state refresh failed (will retry on next poll): %s', (0, settings_1.errorMessage)(err));
-        });
-        this.pollTimer = setInterval(() => {
-            this.requestStateRefresh().catch(err => {
-                this.log.warn('Background poll failed: %s', (0, settings_1.errorMessage)(err));
-            });
-        }, intervalSeconds * 1000);
+        // Immediate initial fetch, then schedule recurring
+        this.poll();
+    }
+    poll() {
+        this.requestStateRefresh()
+            .then(() => this.onPollSuccess())
+            .catch(err => this.onPollFailure((0, settings_1.errorMessage)(err)))
+            .finally(() => this.schedulePoll());
+    }
+    schedulePoll() {
+        this.pollTimer = setTimeout(() => this.poll(), this.pollIntervalMs);
+    }
+    static MAX_POLL_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes
+    onPollSuccess() {
+        if (this.consecutiveFailures > 0) {
+            this.log.info('Poll succeeded after %d consecutive failure(s)', this.consecutiveFailures);
+        }
+        this.consecutiveFailures = 0;
+        this.reachable = true;
+        if (this.pollIntervalMs !== this.basePollIntervalMs) {
+            this.pollIntervalMs = this.basePollIntervalMs;
+            this.log.info('Poll interval reset to %ds', this.pollIntervalMs / 1000);
+        }
+    }
+    onPollFailure(message) {
+        this.consecutiveFailures++;
+        this.log.warn('Background poll failed (%d/%d): %s', this.consecutiveFailures, settings_1.UNREACHABLE_THRESHOLD, message);
+        if (this.consecutiveFailures >= settings_1.UNREACHABLE_THRESHOLD && this.reachable) {
+            this.markUnreachable();
+        }
+    }
+    markUnreachable() {
+        this.reachable = false;
+        // Exponential backoff: double the poll interval, capped at 10 minutes
+        const newInterval = Math.min(this.pollIntervalMs * 2, LovesacDevice.MAX_POLL_INTERVAL_MS);
+        if (newInterval !== this.pollIntervalMs) {
+            this.pollIntervalMs = newInterval;
+            this.log.info('Poll interval backed off to %ds', this.pollIntervalMs / 1000);
+        }
+        this.log.warn('Device unreachable after %d consecutive poll failures — resetting cached state', this.consecutiveFailures);
+        // Reset state to sentinels so next successful connection triggers full re-sync
+        (0, responses_1.resetState)(this.state);
+        this.stateInitialized = false;
+        for (const listener of this.unreachableListeners) {
+            try {
+                listener();
+            }
+            catch (err) {
+                this.log.error('Unreachable listener error: %s', (0, settings_1.errorMessage)(err));
+            }
+        }
     }
     stopPolling() {
         if (this.pollTimer) {
-            clearInterval(this.pollTimer);
+            clearTimeout(this.pollTimer);
             this.pollTimer = null;
         }
     }
@@ -148,10 +198,18 @@ class LovesacDevice {
         return Math.round((percent / 100) * settings_1.MAX_VOLUME);
     }
     async volumeUp(step) {
+        if (!this.stateInitialized) {
+            this.log.warn('volumeUp ignored — state not yet initialized');
+            return;
+        }
         const newVol = Math.min(settings_1.MAX_VOLUME, this.state.volume + step);
         await this.setVolume(newVol);
     }
     async volumeDown(step) {
+        if (!this.stateInitialized) {
+            this.log.warn('volumeDown ignored — state not yet initialized');
+            return;
+        }
         const newVol = Math.max(0, this.state.volume - step);
         await this.setVolume(newVol);
     }
@@ -210,7 +268,18 @@ class LovesacDevice {
             this.log.warn('Out-of-range value for %s: %d (ignored)', CODE_NAMES[parsed.code] ?? `0x${parsed.code.toString(16)}`, parsed.value);
             return;
         }
-        this.stateInitialized = true;
+        // Only mark initialized once we've received a Power notification,
+        // which is included in every state dump. This prevents onGet from
+        // returning stale sentinel values for fields we haven't received yet.
+        if (parsed.code === constants_1.ResponseCode.Power) {
+            this.stateInitialized = true;
+        }
+        // Any valid notification means the device is reachable
+        if (this.consecutiveFailures > 0 || !this.reachable) {
+            this.log.info('Device reachable again after %d poll failure(s)', this.consecutiveFailures);
+            this.consecutiveFailures = 0;
+            this.reachable = true;
+        }
         if (changed) {
             this.log.debug('State: %s = %s', CODE_NAMES[parsed.code] ?? `0x${parsed.code.toString(16)}`, formatStateValue(parsed.code, parsed.value));
             for (const listener of this.stateListeners) {

package/dist/protocol/commands.js

@@ -29,7 +29,7 @@ function eqCommand(subCmdId, value) {
 }
 // Volume: 0-36
 function setVolume(volume) {
-    return eqCommand(0x02, Math.max(0, Math.min(36, volume)));
+    return eqCommand(0x02, Math.max(0, Math.min(36, volume))); // MAX_VOLUME = 36 (from protocol)
 }
 // Bass: 0-20
 function setBass(bass) {
@@ -90,7 +90,8 @@ function requestDeviceInfo() {
         data: formatB(0x01, 0x01),
     };
 }
-// Request version info (AA 01 01 01 — last byte 01 distinguishes from state request)
+// Request version info — uses a 4-byte payload (not formatB's 3-byte) because
+// the trailing 0x01 distinguishes it from the state request (AA 01 01 00).
 function requestVersionInfo() {
     return {
         characteristicUuid: settings_1.CharUUID.DeviceInfo,

package/dist/protocol/responses.d.ts

@@ -14,6 +14,12 @@ export interface DeviceState {
     subwooferConnected: boolean;
 }
 export declare function createDefaultState(): DeviceState;
+/**
+ * Reset an existing DeviceState in-place to sentinel defaults.
+ * This ensures the next state dump from the device will trigger
+ * change events for every field (same mechanism as initial state).
+ */
+export declare function resetState(state: DeviceState): void;
 export interface ParsedResponse {
     code: ResponseCode;
     value: number;
@@ -31,6 +37,6 @@ export declare function parseNotification(data: Buffer): ParsedResponse | undefi
  * Apply a parsed response to the device state. Returns true if state changed.
  * Out-of-range values are logged and ignored to guard against firmware bugs.
  */
-export declare function applyResponse(state: DeviceState, response: ParsedResponse): boolean;
+export declare function applyResponse(state: DeviceState, response: ParsedResponse): boolean | typeof OUT_OF_RANGE;
 /** Sentinel: applyResponse returns this for out-of-range values so the caller can log a warning. */
-export declare const OUT_OF_RANGE: boolean;
+export declare const OUT_OF_RANGE: "out_of_range";

package/dist/protocol/responses.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OUT_OF_RANGE = void 0;
 exports.createDefaultState = createDefaultState;
+exports.resetState = resetState;
 exports.parseNotification = parseNotification;
 exports.applyResponse = applyResponse;
 const constants_1 = require("./constants");
@@ -23,6 +24,14 @@ function createDefaultState() {
         subwooferConnected: false,
     };
 }
+/**
+ * Reset an existing DeviceState in-place to sentinel defaults.
+ * This ensures the next state dump from the device will trigger
+ * change events for every field (same mechanism as initial state).
+ */
+function resetState(state) {
+    Object.assign(state, createDefaultState());
+}
 /**
  * Parse a BLE notification from the UpStream characteristic.
  * Returns the response code and value, or undefined if not a standard status response.

package/dist/settings.d.ts

@@ -17,6 +17,17 @@ export declare const CharUUID: {
 };
 export declare const MAX_VOLUME = 36;
 export declare const BLE_SCAN_TIMEOUT = 15000;
+export declare const BLE_CONNECT_TIMEOUT = 30000;
+export declare const BLE_WRITE_TIMEOUT = 10000;
+export declare const BLE_DISCONNECT_TIMEOUT = 10000;
+export declare const BLE_DISCOVER_TIMEOUT = 15000;
+export declare const UNREACHABLE_THRESHOLD = 3;
+/**
+ * Race a promise against a timeout. Rejects with a descriptive error if
+ * the timeout fires first. The underlying promise is NOT cancelled — the
+ * caller must handle cleanup.
+ */
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T>;
 export declare function errorMessage(err: unknown): string;
 export interface LovesacDeviceConfig {
     name: string;

package/dist/settings.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BLE_SCAN_TIMEOUT = exports.MAX_VOLUME = exports.CharUUID = exports.SOFA_SERVICE_UUID_SHORT = exports.SOFA_SERVICE_UUID = exports.PLATFORM_NAME = exports.PLUGIN_NAME = void 0;
+exports.UNREACHABLE_THRESHOLD = exports.BLE_DISCOVER_TIMEOUT = exports.BLE_DISCONNECT_TIMEOUT = exports.BLE_WRITE_TIMEOUT = exports.BLE_CONNECT_TIMEOUT = exports.BLE_SCAN_TIMEOUT = exports.MAX_VOLUME = exports.CharUUID = exports.SOFA_SERVICE_UUID_SHORT = exports.SOFA_SERVICE_UUID = exports.PLATFORM_NAME = exports.PLUGIN_NAME = void 0;
+exports.withTimeout = withTimeout;
 exports.errorMessage = errorMessage;
 exports.resolveDeviceConfig = resolveDeviceConfig;
 exports.PLUGIN_NAME = 'homebridge-lovesac-stealthtech';
@@ -23,6 +24,25 @@ exports.CharUUID = {
 };
 exports.MAX_VOLUME = 36;
 exports.BLE_SCAN_TIMEOUT = 15000;
+// BLE operation timeouts (milliseconds)
+exports.BLE_CONNECT_TIMEOUT = 30_000;
+exports.BLE_WRITE_TIMEOUT = 10_000;
+exports.BLE_DISCONNECT_TIMEOUT = 10_000;
+exports.BLE_DISCOVER_TIMEOUT = 15_000;
+// Consecutive poll failures before marking device unreachable
+exports.UNREACHABLE_THRESHOLD = 3;
+/**
+ * Race a promise against a timeout. Rejects with a descriptive error if
+ * the timeout fires first. The underlying promise is NOT cancelled — the
+ * caller must handle cleanup.
+ */
+function withTimeout(promise, ms, label) {
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    });
+    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
 function errorMessage(err) {
     return err instanceof Error ? err.message : String(err);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-lovesac-stealthtech",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "description": "Homebridge plugin for Lovesac StealthTech Sound + Charge BLE control",
   "main": "dist/index.js",
   "files": [