homebridge-lovesac-stealthtech 0.0.0-development

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alex Rosenberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,155 @@
+# homebridge-lovesac-stealthtech
+
+Homebridge plugin for the [**Lovesac StealthTech Sound + Charge**](https://www.lovesac.com/stealthtech.html) system. Control your StealthTech soundbar from Apple HomeKit using Bluetooth.
+
+## Features
+
+- **Power on/off** from HomeKit and Siri
+- **Input switching** — HDMI-ARC, Bluetooth, AUX, Optical
+- **Volume control** — slider in the Home app, plus volume buttons in Control Center
+- **Mute** toggle
+- **Audio presets** — Movies, Music, TV, News as individual switches
+- **Quiet mode** toggle
+- **Auto-discovery** — finds your StealthTech device automatically
+- **Background polling** — keeps HomeKit in sync when settings change elsewhere
+
+## Requirements
+
+- [Homebridge](https://homebridge.io) v1.8.0 or later
+- Node.js 18, 20, or 22
+- Bluetooth adapter (built-in on Mac; USB dongle on Linux/Raspberry Pi)
+- macOS, Linux, or Raspberry Pi (any platform supported by [@stoprocent/noble](https://github.com/nicolo-ribaudo/noble))
+
+## Installation
+
+### Via Homebridge UI
+
+Search for `homebridge-lovesac-stealthtech` in the Homebridge UI plugin tab.
+
+### Via CLI
+
+```sh
+npm install -g homebridge-lovesac-stealthtech
+```
+
+## Pairing
+
+This plugin uses the Television service, which Apple requires as an **external accessory**. It won't appear automatically — you need to add it by hand:
+
+1. Open the **Home** app on your iPhone or iPad
+2. Tap **+** → **Add Accessory**
+3. Tap **More Options...**
+4. Select **Lovesac StealthTech**
+5. Enter the setup code from your Homebridge config (default: `031-45-154`)
+
+> **Note:** Due to a known Apple bug, the input sources and preset switches may all show generic names (like "Input Source 2") when you first add the accessory. Just accept the defaults — the plugin will correct all the names automatically within a few moments.
+
+## Using It
+
+| Accessory | What it does |
+|---|---|
+| **Lovesac StealthTech** | Power on/off, input source selection |
+| **Volume** (Fan or Lightbulb tile) | Volume slider (0–100%); on/off toggles mute |
+| **Movies / Music / TV / News Mode** (Switch tiles) | Activate audio presets (one at a time) |
+| **Quiet Mode** (Switch tile) | Toggle quiet mode |
+
+### Control Center Remote
+
+The Lovesac StealthTech appears in the Control Center remote (the Apple TV Remote widget). Select it from the device picker at the top, then:
+
+- **Up/Down arrows** — Volume up/down
+- **Play/Pause** — Toggle mute
+- **Info (i)** — Cycle through presets
+
+### Siri
+
+Siri support for external accessories (which the Television service requires) is limited. Basic commands like "turn on" or "set volume" may conflict with other devices in the same room. Siri via HomePod may work better than from an iPhone. The Control Center remote is the most reliable way to control the StealthTech without opening the Home app.
+
+## Important: Only One Bluetooth Connection at a Time
+
+The StealthTech hardware allows **only one Bluetooth connection at a time**. This means the Homebridge plugin and the Lovesac mobile app can't be connected simultaneously.
+
+The plugin handles this gracefully — it connects briefly to send commands or check the current state, then disconnects so the Bluetooth slot is free. With the default settings, the plugin is connected for roughly 5 seconds every 90 seconds, leaving the connection open for the Lovesac app about 94% of the time.
+
+### Tips for using both HomeKit and the Lovesac app
+
+- **Close the Lovesac app when you're done with it.** The app holds the connection open while it's in the foreground (and sometimes in the background). While the app is connected, HomeKit commands won't go through.
+- **Force-quit the app** if HomeKit seems stuck. The app may be holding the connection in the background.
+- You can **increase the poll interval** in the config if you use the Lovesac app frequently. A longer interval gives the app more time to connect, though HomeKit will be slower to pick up changes made outside of it.
+
+### If HomeKit shows "Not Responding"
+
+This usually means a Bluetooth command timed out. Common causes:
+
+- The Lovesac mobile app has the connection open (close or force-quit it)
+- The StealthTech device is too far from your Home Hub (Apple TV, HomePod, or iPad) — Bluetooth range is between the Hub and the soundbar, not your phone
+- Another Bluetooth client is connected to the device
+
+The plugin will automatically retry on the next poll or the next time you send a command.
+
+## Configuration
+
+The minimal config is all most people need — the plugin will find your StealthTech device automatically:
+
+```json
+{
+  "platform": "LovesacStealthTech",
+  "devices": [
+    {
+      "name": "Lovesac StealthTech"
+    }
+  ]
+}
+```
+
+### All Options
+
+```json
+{
+  "platform": "LovesacStealthTech",
+  "devices": [
+    {
+      "name": "Lovesac StealthTech",
+      "address": "",
+      "idleTimeout": 60,
+      "pollInterval": 90,
+      "volumeControl": "fan",
+      "volumeStep": 2,
+      "presets": {
+        "movies": true,
+        "music": true,
+        "tv": true,
+        "news": true
+      }
+    }
+  ]
+}
+```
+
+| Option | Default | Description |
+|---|---|---|
+| `name` | `"Lovesac StealthTech"` | Name of the accessory in HomeKit. |
+| `address` | *(auto-discover)* | BLE address. Leave blank for auto-discovery. Use `npx homebridge-lovesac-stealthtech scan` to find the address if auto-discovery fails. |
+| `idleTimeout` | `60` | Seconds to wait after the last command before disconnecting. Range: 10–600. |
+| `pollInterval` | `90` | Seconds between background state checks. Longer intervals make it easier to use the Lovesac app alongside HomeKit; shorter intervals keep HomeKit more up to date. Set to `0` to disable polling entirely. Range: 0–600. |
+| `volumeControl` | `"fan"` | How to expose the volume slider: `"fan"`, `"lightbulb"`, or `"none"`. Fan is recommended — Siri can "set Volume to 50%". |
+| `volumeStep` | `2` | Volume increment for Control Center remote up/down buttons. Range: 1–5. |
+| `presets` | all enabled | Show or hide individual preset switches (movies, music, tv, news). |
+
+> **Note:** Keep `pollInterval` larger than `idleTimeout` so the plugin actually disconnects between polls.
+
+### Scanner
+
+If auto-discovery doesn't find your device (e.g., you have multiple StealthTech systems), you can scan manually:
+
+```sh
+npx homebridge-lovesac-stealthtech scan
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and build instructions.
+
+## License
+
+[MIT](LICENSE)

package/config.schema.json

@@ -0,0 +1,96 @@
+{
+  "pluginAlias": "LovesacStealthTech",
+  "pluginType": "platform",
+  "singular": true,
+  "headerDisplay": "Control your Lovesac StealthTech Sound + Charge system via BLE.",
+  "footerDisplay": "The plugin will automatically discover your StealthTech device via Bluetooth. You only need to set the BLE address if auto-discovery doesn't work.",
+  "schema": {
+    "type": "object",
+    "properties": {
+      "devices": {
+        "title": "Devices",
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "name": {
+              "title": "Name",
+              "type": "string",
+              "default": "Lovesac StealthTech",
+              "description": "The name of the accessory as it appears in HomeKit."
+            },
+            "address": {
+              "title": "BLE Address (optional)",
+              "type": "string",
+              "description": "Leave blank for auto-discovery. Only needed if you have multiple StealthTech devices or auto-discovery fails. Use `npx homebridge-lovesac-stealthtech scan` to find the address.",
+              "placeholder": "Auto-discover"
+            },
+            "idleTimeout": {
+              "title": "Idle Timeout (seconds)",
+              "type": "integer",
+              "default": 60,
+              "minimum": 10,
+              "maximum": 600,
+              "description": "Disconnect BLE after this many seconds of inactivity. Allows the Lovesac mobile app to connect."
+            },
+            "pollInterval": {
+              "title": "Poll Interval (seconds)",
+              "type": "integer",
+              "default": 90,
+              "minimum": 0,
+              "maximum": 600,
+              "description": "How often to check the device for state changes. Lower values give more responsive UI but keep the BLE connection active more often, which may prevent the Lovesac mobile app from connecting. Set to 0 to disable background polling. Should be greater than Idle Timeout to free the BLE slot between polls."
+            },
+            "volumeControl": {
+              "title": "Volume Control Type",
+              "type": "string",
+              "default": "fan",
+              "oneOf": [
+                { "title": "Fan (Recommended)", "enum": ["fan"] },
+                { "title": "Lightbulb", "enum": ["lightbulb"] },
+                { "title": "None (remote buttons only)", "enum": ["none"] }
+              ],
+              "description": "Accessory type used to expose volume as a percentage slider for Siri control."
+            },
+            "volumeStep": {
+              "title": "Volume Step",
+              "type": "integer",
+              "default": 2,
+              "minimum": 1,
+              "maximum": 5,
+              "description": "Volume increment/decrement for remote button presses."
+            },
+            "presets": {
+              "title": "Preset Switches",
+              "type": "object",
+              "properties": {
+                "movies": {
+                  "title": "Movies Mode",
+                  "type": "boolean",
+                  "default": true
+                },
+                "music": {
+                  "title": "Music Mode",
+                  "type": "boolean",
+                  "default": true
+                },
+                "tv": {
+                  "title": "TV Mode",
+                  "type": "boolean",
+                  "default": true
+                },
+                "news": {
+                  "title": "News Mode",
+                  "type": "boolean",
+                  "default": true
+                }
+              },
+              "additionalProperties": false
+            }
+          },
+          "required": []
+        }
+      }
+    }
+  }
+}

package/dist/accessory.d.ts

@@ -0,0 +1,36 @@
+import type { PlatformAccessory } from 'homebridge';
+import type { LovesacPlatform } from './platform';
+import type { LovesacDeviceConfig } from './settings';
+import { LovesacDevice } from './protocol/LovesacDevice';
+export declare class LovesacAccessory {
+    private readonly platform;
+    private readonly accessory;
+    private readonly config;
+    private readonly device;
+    private readonly tvService;
+    private readonly speakerService;
+    private volumeService;
+    private readonly inputSources;
+    private readonly presetSwitches;
+    private quietModeService;
+    private volumeDebounceTimer;
+    private readonly Characteristic;
+    constructor(platform: LovesacPlatform, accessory: PlatformAccessory, config: LovesacDeviceConfig, device: LovesacDevice);
+    private setPower;
+    private setActiveIdentifier;
+    private setRemoteKey;
+    private setMute;
+    private setVolumeSelector;
+    private setVolumeOn;
+    private setVolumePercent;
+    /**
+     * Workaround for tvOS 18+ Home Hub bug (homebridge/homebridge#3703).
+     * The Home Hub forcibly renames services to localized generic defaults
+     * during setup. We reject all renames and always push back the name
+     * from the Homebridge config — language-independent.
+     */
+    private setupConfiguredNameHandler;
+    private cyclePreset;
+    private updatePresetSwitches;
+    private handleStateChange;
+}

package/dist/accessory.js

@@ -0,0 +1,352 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LovesacAccessory = void 0;
+const hap_nodejs_1 = require("hap-nodejs");
+const settings_1 = require("./settings");
+const constants_1 = require("./protocol/constants");
+class LovesacAccessory {
+    platform;
+    accessory;
+    config;
+    device;
+    tvService;
+    speakerService;
+    volumeService = null;
+    inputSources = [];
+    presetSwitches = [];
+    quietModeService = null;
+    volumeDebounceTimer = null;
+    Characteristic;
+    constructor(platform, accessory, config, device) {
+        this.platform = platform;
+        this.accessory = accessory;
+        this.config = config;
+        this.device = device;
+        this.Characteristic = this.platform.api.hap.Characteristic;
+        const Service = this.platform.api.hap.Service;
+        // --- Accessory Information ---
+        const infoService = this.accessory.getService(Service.AccessoryInformation) ??
+            this.accessory.addService(Service.AccessoryInformation);
+        infoService
+            .setCharacteristic(this.Characteristic.Manufacturer, 'Lovesac')
+            .setCharacteristic(this.Characteristic.Model, 'StealthTech Sound + Charge')
+            .setCharacteristic(this.Characteristic.SerialNumber, this.config.address || 'Auto')
+            .setCharacteristic(this.Characteristic.FirmwareRevision, '0.0');
+        // Update serial number and firmware after BLE connects
+        this.device.onVersionResolved(() => {
+            const addr = this.device.getResolvedAddress();
+            if (addr && addr !== this.config.address) {
+                infoService.updateCharacteristic(this.Characteristic.SerialNumber, addr);
+            }
+            if (this.device.mcuVersion) {
+                infoService.updateCharacteristic(this.Characteristic.FirmwareRevision, this.device.mcuVersion);
+            }
+        });
+        // --- Television (primary) ---
+        // tvOS 18 workaround: pass name as displayName, use setValue() for ConfiguredName,
+        // and add onGet/onSet to reject bogus "TV" renames from Apple TV Home Hub.
+        // 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);
+        // 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);
+        this.platform.log.info('TV ConfiguredName set to "%s", Name set to "%s"', this.tvService.getCharacteristic(this.Characteristic.ConfiguredName).value, this.tvService.getCharacteristic(this.Characteristic.Name).value);
+        this.setupConfiguredNameHandler(this.tvService, this.config.name);
+        // Active (power)
+        this.tvService.getCharacteristic(this.Characteristic.Active)
+            .onSet(this.setPower.bind(this));
+        // ActiveIdentifier (input source)
+        this.tvService.getCharacteristic(this.Characteristic.ActiveIdentifier)
+            .onSet(this.setActiveIdentifier.bind(this));
+        // Remote key
+        this.tvService.getCharacteristic(this.Characteristic.RemoteKey)
+            .onSet(this.setRemoteKey.bind(this));
+        // --- Input Sources ---
+        const InputSourceType = this.Characteristic.InputSourceType;
+        const inputConfigs = [
+            { name: 'HDMI-ARC', source: constants_1.SourceValue.HDMI, identifier: 1, type: InputSourceType.HDMI },
+            { name: 'Bluetooth', source: constants_1.SourceValue.Bluetooth, identifier: 2, type: InputSourceType.OTHER },
+            { name: 'AUX', source: constants_1.SourceValue.AUX, identifier: 3, type: InputSourceType.OTHER },
+            { name: 'Optical', source: constants_1.SourceValue.Optical, identifier: 4, type: InputSourceType.OTHER },
+        ];
+        for (const input of inputConfigs) {
+            // Pass name as displayName for tvOS 18 compatibility
+            const inputService = this.accessory.addService(Service.InputSource, input.name, `input-${input.identifier}`);
+            // Set Identifier first — critical for HomeKit
+            inputService.setCharacteristic(this.Characteristic.Identifier, input.identifier);
+            // Use setValue() for ConfiguredName and Name to ensure proper HAP notification
+            inputService.getCharacteristic(this.Characteristic.ConfiguredName).setValue(input.name);
+            inputService.getCharacteristic(this.Characteristic.Name).setValue(input.name);
+            this.platform.log.info('Input[%d] ConfiguredName="%s", Name="%s"', input.identifier, inputService.getCharacteristic(this.Characteristic.ConfiguredName).value, inputService.getCharacteristic(this.Characteristic.Name).value);
+            inputService
+                .setCharacteristic(this.Characteristic.IsConfigured, this.Characteristic.IsConfigured.CONFIGURED)
+                .setCharacteristic(this.Characteristic.InputSourceType, input.type)
+                .setCharacteristic(this.Characteristic.CurrentVisibilityState, this.Characteristic.CurrentVisibilityState.SHOWN)
+                .setCharacteristic(this.Characteristic.TargetVisibilityState, this.Characteristic.TargetVisibilityState.SHOWN);
+            this.setupConfiguredNameHandler(inputService, input.name);
+            this.tvService.addLinkedService(inputService);
+            this.inputSources.push(inputService);
+        }
+        // --- Television Speaker ---
+        this.speakerService = this.accessory.addService(Service.TelevisionSpeaker, 'Speaker', 'speaker');
+        this.speakerService
+            .setCharacteristic(this.Characteristic.VolumeControlType, this.Characteristic.VolumeControlType.RELATIVE_WITH_CURRENT);
+        this.speakerService.getCharacteristic(this.Characteristic.Mute)
+            .onSet(this.setMute.bind(this));
+        this.speakerService.getCharacteristic(this.Characteristic.VolumeSelector)
+            .onSet(this.setVolumeSelector.bind(this));
+        this.tvService.addLinkedService(this.speakerService);
+        // --- Volume Proxy (Fan or Lightbulb) ---
+        if (this.config.volumeControl === 'fan' || this.config.volumeControl === 'lightbulb') {
+            const isFan = this.config.volumeControl === 'fan';
+            const svcType = isFan ? Service.Fan : Service.Lightbulb;
+            const subtype = isFan ? 'volume-fan' : 'volume-lightbulb';
+            this.volumeService = this.accessory.addService(svcType, 'Volume', subtype);
+            this.volumeService.addOptionalCharacteristic(this.Characteristic.ConfiguredName);
+            this.volumeService.getCharacteristic(this.Characteristic.ConfiguredName).setValue('Volume');
+            this.setupConfiguredNameHandler(this.volumeService, 'Volume');
+            this.volumeService.getCharacteristic(this.Characteristic.On)
+                .onSet(this.setVolumeOn.bind(this));
+            const levelChar = isFan ? this.Characteristic.RotationSpeed : this.Characteristic.Brightness;
+            this.volumeService.getCharacteristic(levelChar)
+                .onSet(this.setVolumePercent.bind(this));
+        }
+        // --- Preset Switches ---
+        const presetConfigs = [
+            { key: 'movies', name: 'Movies Mode', readVal: constants_1.PresetReadValue.Movies, writeVal: constants_1.PresetWriteValue.Movies },
+            { key: 'music', name: 'Music Mode', readVal: constants_1.PresetReadValue.Music, writeVal: constants_1.PresetWriteValue.Music },
+            { key: 'tv', name: 'TV Mode', readVal: constants_1.PresetReadValue.TV, writeVal: constants_1.PresetWriteValue.TV },
+            { key: 'news', name: 'News Mode', readVal: constants_1.PresetReadValue.News, writeVal: constants_1.PresetWriteValue.News },
+        ];
+        for (const preset of presetConfigs) {
+            if (!this.config.presets[preset.key]) {
+                continue;
+            }
+            const switchService = this.accessory.addService(Service.Switch, preset.name, `preset-${preset.key}`);
+            switchService.addOptionalCharacteristic(this.Characteristic.ConfiguredName);
+            switchService.getCharacteristic(this.Characteristic.ConfiguredName).setValue(preset.name);
+            this.setupConfiguredNameHandler(switchService, preset.name);
+            switchService.getCharacteristic(this.Characteristic.On)
+                .onSet(async (value) => {
+                if (!value) {
+                    return; // Turning off is a no-op — can't unselect a preset
+                }
+                try {
+                    await this.device.setPreset(preset.writeVal);
+                    this.updatePresetSwitches(preset.readVal);
+                }
+                catch (err) {
+                    this.platform.log.error('setPreset failed: %s', (0, settings_1.errorMessage)(err));
+                    throw new hap_nodejs_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+                }
+            });
+            this.presetSwitches.push({
+                service: switchService,
+                presetRead: preset.readVal,
+                presetWrite: preset.writeVal,
+            });
+        }
+        // --- Quiet Mode ---
+        this.quietModeService = this.accessory.addService(Service.Switch, 'Quiet Mode', 'quiet-mode');
+        this.quietModeService.addOptionalCharacteristic(this.Characteristic.ConfiguredName);
+        this.quietModeService.getCharacteristic(this.Characteristic.ConfiguredName).setValue('Quiet Mode');
+        this.setupConfiguredNameHandler(this.quietModeService, 'Quiet Mode');
+        this.quietModeService.getCharacteristic(this.Characteristic.On)
+            .onSet(async (value) => {
+            try {
+                await this.device.setQuietMode(value);
+            }
+            catch (err) {
+                this.platform.log.error('setQuietMode failed: %s', (0, settings_1.errorMessage)(err));
+                throw new hap_nodejs_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+            }
+        });
+        // --- Listen for device state changes ---
+        this.device.onStateChange(this.handleStateChange.bind(this));
+        // Start background polling (also triggers initial state fetch via onReconnect)
+        this.device.startPolling(this.config.pollInterval);
+    }
+    // --- Power ---
+    async setPower(value) {
+        try {
+            const on = value === this.Characteristic.Active.ACTIVE;
+            await this.device.setPower(on);
+        }
+        catch (err) {
+            this.platform.log.error('setPower failed: %s', (0, settings_1.errorMessage)(err));
+            throw new hap_nodejs_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+        }
+    }
+    // --- Input Source ---
+    // HomeKit Identifier 1-4 maps to SourceValue 0-3
+    async setActiveIdentifier(value) {
+        try {
+            const source = value - 1;
+            await this.device.setSource(source);
+        }
+        catch (err) {
+            this.platform.log.error('setActiveIdentifier failed: %s', (0, settings_1.errorMessage)(err));
+            throw new hap_nodejs_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+        }
+    }
+    // --- Remote Key ---
+    async setRemoteKey(value) {
+        try {
+            const RemoteKey = this.Characteristic.RemoteKey;
+            switch (value) {
+                case RemoteKey.ARROW_UP:
+                    await this.device.volumeUp(this.config.volumeStep);
+                    break;
+                case RemoteKey.ARROW_DOWN:
+                    await this.device.volumeDown(this.config.volumeStep);
+                    break;
+                case RemoteKey.SELECT:
+                case RemoteKey.PLAY_PAUSE:
+                    await this.device.setMute(!this.device.state.mute);
+                    break;
+                case RemoteKey.INFORMATION:
+                    await this.cyclePreset();
+                    break;
+            }
+        }
+        catch (err) {
+            this.platform.log.error('setRemoteKey failed: %s', (0, settings_1.errorMessage)(err));
+            throw new hap_nodejs_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+        }
+    }
+    // --- Mute ---
+    async setMute(value) {
+        try {
+            await this.device.setMute(value);
+        }
+        catch (err) {
+            this.platform.log.error('setMute failed: %s', (0, settings_1.errorMessage)(err));
+            throw new hap_nodejs_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+        }
+    }
+    // --- Volume Selector (up/down buttons in Control Center remote) ---
+    async setVolumeSelector(value) {
+        try {
+            if (value === this.Characteristic.VolumeSelector.INCREMENT) {
+                await this.device.volumeUp(this.config.volumeStep);
+            }
+            else {
+                await this.device.volumeDown(this.config.volumeStep);
+            }
+        }
+        catch (err) {
+            this.platform.log.error('setVolumeSelector failed: %s', (0, settings_1.errorMessage)(err));
+            throw new hap_nodejs_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+        }
+    }
+    // --- Volume Proxy (Fan/Lightbulb) ---
+    async setVolumeOn(value) {
+        if (!value) {
+            await this.device.setMute(true);
+        }
+        else if (this.device.state.mute) {
+            await this.device.setMute(false);
+        }
+    }
+    setVolumePercent(value) {
+        const percent = value;
+        // Debounce: HomeKit slider sends many rapid updates
+        if (this.volumeDebounceTimer) {
+            clearTimeout(this.volumeDebounceTimer);
+        }
+        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 ---
+    /**
+     * Workaround for tvOS 18+ Home Hub bug (homebridge/homebridge#3703).
+     * The Home Hub forcibly renames services to localized generic defaults
+     * during setup. We reject all renames and always push back the name
+     * from the Homebridge config — language-independent.
+     */
+    setupConfiguredNameHandler(service, originalName) {
+        const subtype = service.subtype ?? '(primary)';
+        service.getCharacteristic(this.Characteristic.ConfiguredName)
+            .onGet(() => {
+            this.platform.log.debug('[%s] ConfiguredName GET → "%s"', subtype, originalName);
+            return originalName;
+        })
+            .onSet((value) => {
+            const newName = value;
+            if (newName === originalName) {
+                this.platform.log.debug('[%s] ConfiguredName SET "%s" (unchanged)', subtype, newName);
+                return;
+            }
+            this.platform.log.info('[%s] Rejecting rename "%s" → pushing back "%s"', subtype, newName, originalName);
+            setTimeout(() => {
+                service.getCharacteristic(this.Characteristic.ConfiguredName).updateValue(originalName);
+            }, 500);
+        });
+    }
+    async cyclePreset() {
+        const enabledPresets = this.presetSwitches.map((s) => s.presetRead);
+        if (enabledPresets.length === 0) {
+            return;
+        }
+        const currentIndex = enabledPresets.indexOf(this.device.state.preset);
+        const nextIndex = (currentIndex + 1) % enabledPresets.length;
+        const nextWrite = (0, constants_1.presetReadToWrite)(enabledPresets[nextIndex]);
+        await this.device.setPreset(nextWrite);
+        this.updatePresetSwitches(enabledPresets[nextIndex]);
+    }
+    updatePresetSwitches(activePreset) {
+        for (const ps of this.presetSwitches) {
+            ps.service.getCharacteristic(this.Characteristic.On)
+                .updateValue(ps.presetRead === activePreset);
+        }
+    }
+    // --- State Change Handler ---
+    handleStateChange(code, _value) {
+        switch (code) {
+            case constants_1.ResponseCode.Power:
+                this.tvService.getCharacteristic(this.Characteristic.Active)
+                    .updateValue(this.device.state.power
+                    ? this.Characteristic.Active.ACTIVE
+                    : this.Characteristic.Active.INACTIVE);
+                break;
+            case constants_1.ResponseCode.Volume:
+                if (this.volumeService) {
+                    const percent = this.device.volumeToPercent(this.device.state.volume);
+                    const levelChar = this.config.volumeControl === 'fan'
+                        ? 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);
+                }
+                break;
+            case constants_1.ResponseCode.Mute:
+                this.speakerService.getCharacteristic(this.Characteristic.Mute)
+                    .updateValue(this.device.state.mute);
+                if (this.volumeService) {
+                    this.volumeService.getCharacteristic(this.Characteristic.On)
+                        .updateValue(!this.device.state.mute && this.device.state.volume > 0);
+                }
+                break;
+            case constants_1.ResponseCode.Source:
+                this.tvService.getCharacteristic(this.Characteristic.ActiveIdentifier)
+                    .updateValue(this.device.state.source + 1);
+                break;
+            case constants_1.ResponseCode.Preset:
+                this.updatePresetSwitches(this.device.state.preset);
+                break;
+            case constants_1.ResponseCode.QuietMode:
+                if (this.quietModeService) {
+                    this.quietModeService.getCharacteristic(this.Characteristic.On)
+                        .updateValue(this.device.state.quietMode);
+                }
+                break;
+        }
+    }
+}
+exports.LovesacAccessory = LovesacAccessory;