homebridge-bedjet 0.1.0

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "homebridge-bedjet",
+  "displayName": "BedJet",
+  "version": "0.1.0",
+  "description": "Homebridge plugin for BedJet V3 via Bluetooth LE",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["homebridge-plugin", "bedjet", "homekit", "bluetooth"],
+  "engines": {
+    "homebridge": ">=1.8.0",
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@abandonware/noble": "^1.9.2-15"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "homebridge": "^2.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/src/accessory.ts

@@ -0,0 +1,195 @@
+import type { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
+import { BedJet } from './bedjet/BedJet';
+import { OperatingMode } from './bedjet/constants';
+import type { BedJetConfig, BedJetState } from './bedjet/types';
+import type { BedJetPlatform } from './platform';
+
+// OperatingMode → CurrentHeatingCoolingState value
+const CURRENT_STATE_MAP: Record<OperatingMode, number> = {
+  [OperatingMode.STANDBY]:       0, // OFF
+  [OperatingMode.HEAT]:          1, // HEAT
+  [OperatingMode.TURBO]:         1, // HEAT
+  [OperatingMode.EXTENDED_HEAT]: 1, // HEAT
+  [OperatingMode.COOL]:          2, // COOL
+  [OperatingMode.DRY]:           2, // COOL
+  [OperatingMode.WAIT]:          0, // OFF
+};
+
+// TargetHeatingCoolingState value → OperatingMode
+const TARGET_TO_MODE: Record<number, OperatingMode> = {
+  0: OperatingMode.STANDBY,
+  1: OperatingMode.HEAT,
+  2: OperatingMode.COOL,
+  3: OperatingMode.HEAT, // AUTO — fall back to heat
+};
+
+export class BedJetAccessory {
+  private readonly thermostatService: Service;
+  private readonly fanService: Service;
+  private readonly bedjet: BedJet;
+
+  // Debounce handles for setter commands
+  private tempDebounce: NodeJS.Timeout | null = null;
+  private fanDebounce: NodeJS.Timeout | null = null;
+
+  constructor(
+    private readonly platform: BedJetPlatform,
+    private readonly accessory: PlatformAccessory,
+    private readonly config: BedJetConfig,
+  ) {
+    const { Service, Characteristic } = platform.api.hap;
+
+    // AccessoryInformation
+    const infoService = this.accessory.getService(Service.AccessoryInformation)
+      ?? this.accessory.addService(Service.AccessoryInformation);
+    infoService
+      .setCharacteristic(Characteristic.Manufacturer, 'BedJet')
+      .setCharacteristic(Characteristic.Model, 'BedJet 3')
+      .setCharacteristic(Characteristic.SerialNumber, config.address);
+
+    // Thermostat service
+    this.thermostatService = this.accessory.getService(Service.Thermostat)
+      ?? this.accessory.addService(Service.Thermostat, config.name, 'thermostat');
+
+    this.thermostatService.getCharacteristic(Characteristic.TemperatureDisplayUnits)
+      .onGet(() => Characteristic.TemperatureDisplayUnits.CELSIUS);
+
+    this.thermostatService.getCharacteristic(Characteristic.CurrentTemperature)
+      .onGet(() => this.bedjet.state.currentTemperature);
+
+    this.thermostatService.getCharacteristic(Characteristic.TargetTemperature)
+      .setProps({ minValue: 19, maxValue: 43, minStep: 0.5 })
+      .onGet(() => this.bedjet.state.targetTemperature)
+      .onSet((value: CharacteristicValue) => {
+        if (this.tempDebounce) {
+          clearTimeout(this.tempDebounce);
+        }
+        this.tempDebounce = setTimeout(() => {
+          this.bedjet.setTemperature(value as number).catch(err =>
+            this.platform.log.error(`[${config.name}] setTemperature failed: ${err}`),
+          );
+        }, 100);
+      });
+
+    this.thermostatService.getCharacteristic(Characteristic.CurrentHeatingCoolingState)
+      .onGet(() => CURRENT_STATE_MAP[this.bedjet.state.operatingMode] ?? 0);
+
+    this.thermostatService.getCharacteristic(Characteristic.TargetHeatingCoolingState)
+      .onGet(() => {
+        const mode = this.bedjet.state.operatingMode;
+        if (mode === OperatingMode.STANDBY || mode === OperatingMode.WAIT) return 0;
+        if (mode === OperatingMode.COOL || mode === OperatingMode.DRY) return 2;
+        return 1; // HEAT / TURBO / EXTENDED_HEAT
+      })
+      .onSet((value: CharacteristicValue) => {
+        const mode = TARGET_TO_MODE[value as number] ?? OperatingMode.STANDBY;
+        this.bedjet.setOperatingMode(mode).catch(err =>
+          this.platform.log.error(`[${config.name}] setOperatingMode failed: ${err}`),
+        );
+      });
+
+    // FanV2 service
+    this.fanService = this.accessory.getService(Service.Fanv2)
+      ?? this.accessory.addService(Service.Fanv2, `${config.name} Fan`, 'fan');
+
+    this.fanService.getCharacteristic(Characteristic.Active)
+      .onGet(() =>
+        this.bedjet.state.operatingMode !== OperatingMode.STANDBY
+          ? Characteristic.Active.ACTIVE
+          : Characteristic.Active.INACTIVE,
+      )
+      .onSet((value: CharacteristicValue) => {
+        if (value === Characteristic.Active.INACTIVE) {
+          this.bedjet.setOperatingMode(OperatingMode.STANDBY).catch(err =>
+            this.platform.log.error(`[${config.name}] setOperatingMode(STANDBY) failed: ${err}`),
+          );
+        } else {
+          // Only turn on if currently off
+          if (this.bedjet.state.operatingMode === OperatingMode.STANDBY) {
+            this.bedjet.setOperatingMode(OperatingMode.HEAT).catch(err =>
+              this.platform.log.error(`[${config.name}] setOperatingMode(HEAT) failed: ${err}`),
+            );
+          }
+        }
+      });
+
+    this.fanService.getCharacteristic(Characteristic.RotationSpeed)
+      .setProps({ minValue: 5, maxValue: 100, minStep: 5 })
+      .onGet(() => this.bedjet.state.fanSpeed)
+      .onSet((value: CharacteristicValue) => {
+        if (this.fanDebounce) {
+          clearTimeout(this.fanDebounce);
+        }
+        this.fanDebounce = setTimeout(() => {
+          this.bedjet.setFanSpeed(value as number).catch(err =>
+            this.platform.log.error(`[${config.name}] setFanSpeed failed: ${err}`),
+          );
+        }, 100);
+      });
+
+    // Create BLE client and wire up state change events
+    this.bedjet = new BedJet(config, platform.log);
+
+    this.bedjet.on('stateChange', (state: BedJetState) => this._syncHomeKit(state));
+    this.bedjet.on('connected', () => {
+      // Update FirmwareRevision once we have it
+      const fw = this.bedjet.firmware;
+      if (fw) {
+        infoService.setCharacteristic(Characteristic.FirmwareRevision, fw);
+      }
+    });
+
+    // Start connecting — errors are logged but don't crash Homebridge
+    this.bedjet.connect().catch(err =>
+      this.platform.log.error(`[${config.name}] Initial connect failed: ${err}`),
+    );
+  }
+
+  private _syncHomeKit(state: BedJetState): void {
+    const { Characteristic } = this.platform.api.hap;
+
+    // Update TargetTemperature bounds from live packet values
+    this.thermostatService
+      .getCharacteristic(Characteristic.TargetTemperature)
+      .setProps({ minValue: state.minimumTemperature, maxValue: state.maximumTemperature });
+
+    this.thermostatService.updateCharacteristic(
+      Characteristic.CurrentTemperature,
+      state.currentTemperature,
+    );
+
+    this.thermostatService.updateCharacteristic(
+      Characteristic.TargetTemperature,
+      state.targetTemperature,
+    );
+
+    this.thermostatService.updateCharacteristic(
+      Characteristic.CurrentHeatingCoolingState,
+      CURRENT_STATE_MAP[state.operatingMode] ?? 0,
+    );
+
+    const targetState =
+      state.operatingMode === OperatingMode.STANDBY || state.operatingMode === OperatingMode.WAIT
+        ? 0
+        : state.operatingMode === OperatingMode.COOL || state.operatingMode === OperatingMode.DRY
+          ? 2
+          : 1;
+
+    this.thermostatService.updateCharacteristic(
+      Characteristic.TargetHeatingCoolingState,
+      targetState,
+    );
+
+    this.fanService.updateCharacteristic(
+      Characteristic.Active,
+      state.operatingMode !== OperatingMode.STANDBY
+        ? Characteristic.Active.ACTIVE
+        : Characteristic.Active.INACTIVE,
+    );
+
+    this.fanService.updateCharacteristic(
+      Characteristic.RotationSpeed,
+      state.fanSpeed,
+    );
+  }
+}

package/src/bedjet/BedJet.ts

@@ -0,0 +1,400 @@
+import { EventEmitter } from 'events';
+import type { Peripheral, Characteristic } from '@abandonware/noble';
+import type { Logger } from 'homebridge';
+
+// noble is a singleton process-level instance; require() gives us the live object.
+// The default ESM export doesn't expose `.state` in its type — we patch it here.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const noble = require('@abandonware/noble') as typeof import('@abandonware/noble') & { state: string };
+import {
+  BEDJET3_SERVICE_UUID,
+  BEDJET3_STATUS_UUID,
+  BEDJET3_NAME_UUID,
+  BEDJET3_COMMAND_UUID,
+  BEDJET3_NOTIFICATION_LENGTH,
+  BEDJET3_STATUS_LENGTH,
+  DISCONNECT_DELAY_MS,
+  MAX_RECONNECT_ATTEMPTS,
+  OperatingMode,
+  BedJetCommand,
+  BedJetButton,
+  OPERATING_MODE_BUTTON_MAP,
+} from './constants';
+import type { BedJetConfig, BedJetState } from './types';
+import { DEFAULT_STATE } from './types';
+
+// noble strips hyphens from UUIDs internally
+const normalize = (uuid: string) => uuid.replace(/-/g, '').toLowerCase();
+
+const NORM_STATUS_UUID  = normalize(BEDJET3_STATUS_UUID);
+const NORM_NAME_UUID    = normalize(BEDJET3_NAME_UUID);
+const NORM_COMMAND_UUID = normalize(BEDJET3_COMMAND_UUID);
+const NORM_SERVICE_UUID = normalize(BEDJET3_SERVICE_UUID);
+
+export class BedJet extends EventEmitter {
+  private peripheral: Peripheral | null = null;
+  private commandChar: Characteristic | null = null;
+  private statusChar: Characteristic | null = null;
+  private disconnectTimer: NodeJS.Timeout | null = null;
+  private staleTimer: NodeJS.Timeout | null = null;
+  private reconnectAttempts = 0;
+  private connecting = false;
+  private _state: BedJetState = { ...DEFAULT_STATE };
+  private deviceName: string | null = null;
+  private firmwareVersion: string | null = null;
+
+  constructor(
+    private readonly config: BedJetConfig,
+    private readonly log: Logger,
+  ) {
+    super();
+  }
+
+  get state(): BedJetState {
+    return this._state;
+  }
+
+  get name(): string {
+    return this.deviceName ?? this.config.name;
+  }
+
+  get firmware(): string | null {
+    return this.firmwareVersion;
+  }
+
+  // ── Connection ────────────────────────────────────────────────────────────
+
+  async connect(): Promise<void> {
+    if (this.connecting) {
+      return;
+    }
+    this.connecting = true;
+
+    try {
+      await this._scan();
+    } catch (err) {
+      this.connecting = false;
+      throw err;
+    }
+
+    this.connecting = false;
+  }
+
+  private _scan(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const targetAddress = this.config.address.toLowerCase().replace(/:/g, '');
+      const timeoutMs = (this.config.scanTimeout ?? 30) * 1000;
+
+      const scanTimeout = setTimeout(() => {
+        noble.stopScanning();
+        noble.removeListener('discover', onDiscover);
+        reject(new Error(`[${this.config.name}] Scan timed out after ${this.config.scanTimeout ?? 30}s`));
+      }, timeoutMs);
+
+      const onDiscover = async (peripheral: Peripheral) => {
+        const addr = peripheral.address.toLowerCase().replace(/:/g, '');
+        if (addr !== targetAddress) {
+          return;
+        }
+
+        clearTimeout(scanTimeout);
+        noble.stopScanning();
+        noble.removeListener('discover', onDiscover);
+
+        try {
+          await this._connectPeripheral(peripheral);
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      };
+
+      noble.on('discover', onDiscover);
+
+      const startScan = () => {
+        // Pass full UUID with hyphens — noble handles normalisation for scanning
+        noble.startScanning([BEDJET3_SERVICE_UUID], false, (err) => {
+          if (err) {
+            clearTimeout(scanTimeout);
+            noble.removeListener('discover', onDiscover);
+            reject(new Error(`[${this.config.name}] startScanning failed: ${err}`));
+          }
+        });
+      };
+
+      if (noble.state === 'poweredOn') {
+        startScan();
+      } else {
+        noble.once('stateChange', (state) => {
+          if (state === 'poweredOn') {
+            startScan();
+          } else {
+            clearTimeout(scanTimeout);
+            noble.removeListener('discover', onDiscover);
+            reject(new Error(`[${this.config.name}] Bluetooth not available (state: ${state})`));
+          }
+        });
+      }
+    });
+  }
+
+  private async _connectPeripheral(peripheral: Peripheral): Promise<void> {
+    this.peripheral = peripheral;
+    this.log.info(`[${this.config.name}] Connecting to ${peripheral.address}…`);
+
+    peripheral.once('disconnect', () => this._onDisconnected());
+
+    await peripheral.connectAsync();
+    this.log.debug(`[${this.config.name}] Connected — discovering services…`);
+
+    const { characteristics } = await peripheral.discoverSomeServicesAndCharacteristicsAsync(
+      [NORM_SERVICE_UUID],
+      [NORM_STATUS_UUID, NORM_NAME_UUID, NORM_COMMAND_UUID],
+    );
+
+    for (const char of characteristics) {
+      const uuid = normalize(char.uuid);
+      if (uuid === NORM_STATUS_UUID) {
+        this.statusChar = char;
+      } else if (uuid === NORM_COMMAND_UUID) {
+        this.commandChar = char;
+      }
+    }
+
+    if (!this.commandChar || !this.statusChar) {
+      throw new Error(`[${this.config.name}] Required characteristics not found`);
+    }
+
+    // Subscribe to notifications on the status characteristic
+    await this.statusChar.subscribeAsync();
+    this.statusChar.on('data', (data: Buffer) => this._handleNotification(data));
+
+    // Read extended status and device name
+    await this._readDeviceStatus();
+    await this._readDeviceName();
+
+    this.reconnectAttempts = 0;
+    this._state = { ...this._state, isConnected: true };
+    this._resetDisconnectTimer();
+    this._resetStaleTimer();
+
+    this.emit('connected');
+    this.emit('stateChange', this._state);
+
+    this.log.info(`[${this.config.name}] Ready (firmware: ${this.firmwareVersion ?? 'unknown'})`);
+  }
+
+  // ── Packet parsing ────────────────────────────────────────────────────────
+
+  private _handleNotification(data: Buffer): void {
+    if (data.length !== BEDJET3_NOTIFICATION_LENGTH) {
+      return;
+    }
+
+    this._state = {
+      ...this._state,
+      hoursRemaining:     data[4],
+      minutesRemaining:   data[5],
+      secondsRemaining:   data[6],
+      currentTemperature: data[7] / 2,
+      targetTemperature:  data[8] / 2,
+      operatingMode:      data[9] as OperatingMode,
+      fanSpeed:           (data[10] + 1) * 5,
+      // data[11] = maximum_hours, data[12] = maximum_minutes (not stored in state)
+      minimumTemperature: data[13] / 2,
+      maximumTemperature: data[14] / 2,
+      // bytes [15–16] = turbo_time uint16 big-endian
+      turboTimeSeconds:   (data[15] << 8) | data[16],
+      ambientTemperature: data[17] / 2,
+      // data[18] = shutdown_reason (not stored)
+      isConnected: true,
+    };
+
+    this._resetStaleTimer();
+    this.emit('stateChange', this._state);
+  }
+
+  private _handleStatusRead(data: Buffer): void {
+    if (data.length !== BEDJET3_STATUS_LENGTH) {
+      return;
+    }
+
+    const flags = data[7];
+    this._state = {
+      ...this._state,
+      isDualZone:    (data[2] & 0x02) !== 0,
+      // flags bits MSB→LSB: [_, _, connTestPassed, ledEnabled, _, unitsSetup, _, beepsMuted]
+      connTestPassed: (flags & 0x20) !== 0,
+      ledEnabled:     (flags & 0x10) !== 0,
+      unitsSetup:     (flags & 0x04) !== 0,
+      beepsMuted:     (flags & 0x01) !== 0,
+      notificationCode: data[9],
+    };
+  }
+
+  private async _readDeviceName(): Promise<void> {
+    if (!this.peripheral) {
+      return;
+    }
+    try {
+      // Rediscover to get the name characteristic
+      const { characteristics } = await this.peripheral.discoverSomeServicesAndCharacteristicsAsync(
+        [NORM_SERVICE_UUID],
+        [NORM_NAME_UUID],
+      );
+      const nameChar = characteristics.find(c => normalize(c.uuid) === NORM_NAME_UUID);
+      if (nameChar) {
+        const data = await nameChar.readAsync();
+        this.deviceName = data.toString('utf8').replace(/\0/g, '').trim();
+        this.log.debug(`[${this.config.name}] Device name: ${this.deviceName}`);
+      }
+    } catch (err) {
+      this.log.warn(`[${this.config.name}] Could not read device name: ${err}`);
+    }
+  }
+
+  private async _readDeviceStatus(): Promise<void> {
+    if (!this.statusChar) {
+      return;
+    }
+    try {
+      const data = await this.statusChar.readAsync();
+      this._handleStatusRead(data);
+    } catch (err) {
+      this.log.warn(`[${this.config.name}] Could not read device status: ${err}`);
+    }
+  }
+
+  // ── Commands ──────────────────────────────────────────────────────────────
+
+  private async _sendCommand(command: BedJetCommand, ...args: number[]): Promise<void> {
+    if (!this.commandChar) {
+      throw new Error(`[${this.config.name}] Not connected`);
+    }
+    const buf = Buffer.from([command, ...args]);
+    try {
+      // withoutResponse = false (write with response) — required for V3
+      await this.commandChar.writeAsync(buf, false);
+      this._resetDisconnectTimer();
+    } catch (err) {
+      this.log.error(`[${this.config.name}] Command 0x${command.toString(16)} failed: ${err}`);
+      throw err;
+    }
+  }
+
+  async setTemperature(celsius: number): Promise<void> {
+    await this._sendCommand(BedJetCommand.SET_TEMPERATURE, Math.round(celsius * 2));
+  }
+
+  async setFanSpeed(percent: number): Promise<void> {
+    const step = Math.max(0, Math.min(19, Math.round(percent / 5) - 1));
+    await this._sendCommand(BedJetCommand.SET_FAN, step);
+  }
+
+  async setOperatingMode(mode: OperatingMode): Promise<void> {
+    await this._sendCommand(BedJetCommand.BUTTON, OPERATING_MODE_BUTTON_MAP[mode]);
+  }
+
+  async pressButton(button: BedJetButton): Promise<void> {
+    await this._sendCommand(BedJetCommand.BUTTON, button);
+  }
+
+  async setClock(hour: number, minute: number): Promise<void> {
+    await this._sendCommand(BedJetCommand.SET_CLOCK, hour, minute);
+  }
+
+  async setRuntimeRemaining(hours: number, minutes: number): Promise<void> {
+    await this._sendCommand(BedJetCommand.SET_RUNTIME, hours, minutes);
+  }
+
+  async setLed(on: boolean): Promise<void> {
+    await this.pressButton(on ? BedJetButton.LED_ON : BedJetButton.LED_OFF);
+  }
+
+  async setMuted(muted: boolean): Promise<void> {
+    await this.pressButton(muted ? BedJetButton.MUTE : BedJetButton.UNMUTE);
+  }
+
+  // ── Timers ────────────────────────────────────────────────────────────────
+
+  private _resetDisconnectTimer(): void {
+    if (this.disconnectTimer) {
+      clearTimeout(this.disconnectTimer);
+    }
+    this.disconnectTimer = setTimeout(async () => {
+      this.log.debug(`[${this.config.name}] Inactivity timeout — disconnecting`);
+      await this.disconnect();
+    }, DISCONNECT_DELAY_MS);
+  }
+
+  // Mark stale and update HomeKit if no notification arrives within 65s
+  private _resetStaleTimer(): void {
+    if (this.staleTimer) {
+      clearTimeout(this.staleTimer);
+    }
+    this.staleTimer = setTimeout(() => {
+      this.log.warn(`[${this.config.name}] No notification received — marking disconnected`);
+      this._state = { ...this._state, isConnected: false };
+      this.emit('stateChange', this._state);
+    }, 65_000);
+  }
+
+  // ── Disconnect / reconnect ────────────────────────────────────────────────
+
+  private _onDisconnected(): void {
+    this.commandChar = null;
+    this.statusChar = null;
+
+    if (this.disconnectTimer) {
+      clearTimeout(this.disconnectTimer);
+      this.disconnectTimer = null;
+    }
+    if (this.staleTimer) {
+      clearTimeout(this.staleTimer);
+      this.staleTimer = null;
+    }
+
+    this._state = { ...this._state, isConnected: false };
+    this.emit('disconnected');
+    this.emit('stateChange', this._state);
+
+    if (this.reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+      // Exponential backoff: 2s, 4s, 8s, 16s, 32s
+      const delay = Math.pow(2, this.reconnectAttempts + 1) * 1000;
+      this.reconnectAttempts++;
+      this.log.info(
+        `[${this.config.name}] Disconnected — reconnecting in ${delay / 1000}s ` +
+        `(attempt ${this.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`,
+      );
+      setTimeout(() => {
+        this.connect().catch(err =>
+          this.log.error(`[${this.config.name}] Reconnect failed: ${err}`),
+        );
+      }, delay);
+    } else {
+      this.log.error(`[${this.config.name}] Max reconnect attempts reached — giving up`);
+      this.emit('maxReconnectReached');
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.disconnectTimer) {
+      clearTimeout(this.disconnectTimer);
+      this.disconnectTimer = null;
+    }
+    if (this.staleTimer) {
+      clearTimeout(this.staleTimer);
+      this.staleTimer = null;
+    }
+    // Setting max attempts prevents the disconnect handler from triggering a reconnect
+    this.reconnectAttempts = MAX_RECONNECT_ATTEMPTS;
+    if (this.peripheral) {
+      try {
+        await this.peripheral.disconnectAsync();
+      } catch {
+        // ignore errors during intentional disconnect
+      }
+      this.peripheral = null;
+    }
+  }
+}

package/src/bedjet/constants.ts

@@ -0,0 +1,83 @@
+// BedJet V3 BLE UUIDs (confirmed from ESPHome + pybedjet)
+export const BEDJET3_SERVICE_UUID      = '00001000-bed0-0080-aa55-4265644a6574';
+export const BEDJET3_STATUS_UUID       = '00002000-bed0-0080-aa55-4265644a6574';
+export const BEDJET3_NAME_UUID         = '00002001-bed0-0080-aa55-4265644a6574';
+export const BEDJET3_SSID_UUID         = '00002002-bed0-0080-aa55-4265644a6574';
+export const BEDJET3_PASSWORD_UUID     = '00002003-bed0-0080-aa55-4265644a6574';
+export const BEDJET3_COMMAND_UUID      = '00002004-bed0-0080-aa55-4265644a6574';
+export const BEDJET3_BIODATA_UUID      = '00002005-bed0-0080-aa55-4265644a6574';
+export const BEDJET3_BIODATA_FULL_UUID = '00002006-bed0-0080-aa55-4265644a6574';
+
+// Discard notification packets that are not exactly this length
+export const BEDJET3_NOTIFICATION_LENGTH = 20;
+// Discard direct status reads that are not exactly this length
+export const BEDJET3_STATUS_LENGTH       = 11;
+
+export const DISCONNECT_DELAY_MS      = 60_000;
+export const MAX_RECONNECT_ATTEMPTS   = 5;
+
+// byte [9] of notification packet
+export enum OperatingMode {
+  STANDBY       = 0,
+  HEAT          = 1,
+  TURBO         = 2,
+  EXTENDED_HEAT = 3,
+  COOL          = 4,  // fan only — no compressor
+  DRY           = 5,
+  WAIT          = 6,  // pause step in a biorhythm program
+}
+
+// Write to BEDJET3_COMMAND_UUID as Buffer.from([command_byte, ...args])
+export enum BedJetCommand {
+  BUTTON          = 0x01,
+  SET_RUNTIME     = 0x02,
+  SET_TEMPERATURE = 0x03,
+  SET_STEP        = 0x04,
+  SET_HACKS       = 0x05,
+  STATUS          = 0x06,
+  SET_FAN         = 0x07,
+  SET_CLOCK       = 0x08,
+  SET_BIO         = 0x40,
+  GET_BIO         = 0x41,
+}
+
+export enum BedJetButton {
+  OFF             = 0x01,
+  COOL            = 0x02,
+  HEAT            = 0x03,
+  TURBO           = 0x04,
+  DRY             = 0x05,
+  EXTENDED_HEAT   = 0x06,
+  M1              = 0x20,
+  M2              = 0x21,
+  M3              = 0x22,
+  DEBUG_ON        = 0x40,
+  DEBUG_OFF       = 0x41,
+  CONNECTION_TEST = 0x42,
+  UPDATE_FIRMWARE = 0x43,
+  LED_ON          = 0x46,
+  LED_OFF         = 0x47,
+  MUTE            = 0x48,
+  UNMUTE          = 0x49,
+  NOTIFY_ACK      = 0x52,
+  BIORHYTHM_1     = 0x80,
+  BIORHYTHM_2     = 0x81,
+  BIORHYTHM_3     = 0x82,
+}
+
+export const OPERATING_MODE_BUTTON_MAP: Record<OperatingMode, BedJetButton> = {
+  [OperatingMode.STANDBY]:       BedJetButton.OFF,
+  [OperatingMode.HEAT]:          BedJetButton.HEAT,
+  [OperatingMode.TURBO]:         BedJetButton.TURBO,
+  [OperatingMode.EXTENDED_HEAT]: BedJetButton.EXTENDED_HEAT,
+  [OperatingMode.COOL]:          BedJetButton.COOL,
+  [OperatingMode.DRY]:           BedJetButton.DRY,
+  [OperatingMode.WAIT]:          BedJetButton.OFF,
+};
+
+export enum BioDataRequest {
+  DEVICE_NAME       = 0,
+  MEMORY_NAMES      = 1,
+  BIORHYTHM_NAMES   = 4,
+  FIRMWARE_VERSIONS = 32,
+}