homebridge-nest-accfactory 0.2.11 → 0.3.0

package/dist/system.js

@@ -1,7 +1,7 @@
 // Nest System communications
 // Part of homebridge-nest-accfactory
 //
-// Code version 2025/03/20
+// Code version 2025.06.13
 // Mark Hulskamp
 'use strict';
 
@@ -15,332 +15,144 @@ import { setInterval, clearInterval, setTimeout, clearTimeout } from 'node:timer
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import process from 'node:process';
-import child_process from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
 // Import our modules
 import HomeKitDevice from './HomeKitDevice.js';
-import NestCamera from './camera.js';
-import NestDoorbell from './doorbell.js';
-import NestFloodlight from './floodlight.js';
-import NestProtect from './protect.js';
-import NestTemperatureSensor from './tempsensor.js';
-import NestWeather from './weather.js';
-import NestThermostat from './thermostat.js';
+import { DeviceType, loadDeviceModules, getDeviceHKCategory } from './devices.js';
+import { AccountType, processConfig, buildConnections } from './config.js';
 
+// Define constants
 const CAMERAALERTPOLLING = 2000; // Camera alerts polling timer
 const CAMERAZONEPOLLING = 30000; // Camera zones changes polling timer
 const WEATHERPOLLING = 300000; // Weather data polling timer
 const NESTAPITIMEOUT = 10000; // Nest API timeout
 const USERAGENT = 'Nest/5.78.0 (iOScom.nestlabs.jasper.release) os=18.0'; // User Agent string
-const FFMPEGVERSION = '6.0'; // Minimum version of ffmpeg we require
-
 const __dirname = path.dirname(fileURLToPath(import.meta.url)); // Make a defined for JS __dirname
+const DATASOURCE = {
+  NestAPI: 'Nest', // From the Nest API
+  ProtobufAPI: 'Protobuf', // From the Protobuf API
+};
 
 // We handle the connections to Nest/Google
 // Perform device management (additions/removals/updates)
 export default class NestAccfactory {
-  static DeviceType = {
-    THERMOSTAT: 'thermostat',
-    TEMPSENSOR: 'temperature',
-    SMOKESENSOR: 'protect',
-    CAMERA: 'camera',
-    DOORBELL: 'doorbell',
-    FLOODLIGHT: 'floodlight',
-    WEATHER: 'weather',
-    LOCK: 'lock', // yet to implement
-    ALARM: 'alarm', // yet to implement
-  };
-
-  static DataSource = {
-    REST: 'REST', // From the REST API
-    PROTOBUF: 'Protobuf', // From the Protobuf API
-  };
-
-  static GoogleAccount = 'google'; // Google account connection
-  static NestAccount = 'nest'; // Nest account connection
-
   cachedAccessories = []; // Track restored cached accessories
 
   // Internal data only for this class
-  #connections = {}; // Object of confirmed connections
-  #rawData = {}; // Cached copy of data from both Rest and Protobuf APIs
+  #connections = undefined; // Object of confirmed connections
+  #rawData = {}; // Cached copy of data from both Nest and Protobuf APIs
   #eventEmitter = new EventEmitter(); // Used for object messaging from this platform
-  #connectionTimer = undefined;
   #protobufRoot = null; // Protobuf loaded protos
   #trackedDevices = {}; // Object of devices we've created. used to track data source type, comms uuid. key'd by serial #
+  #deviceModules = undefined; // No loaded device support modules to start
+
+  constructor(log, config, api, eventEmitter) {
+    // If no explicit event emitter was passed, and the api is an EventEmitter (e.g., in Homebridge),
+    // we'll treat it as the source for lifecycle messages like didFinishLaunching/shutdown in this constructor
+    if (api instanceof EventEmitter && eventEmitter === undefined) {
+      eventEmitter = api;
+    }
 
-  constructor(log, config, api) {
-    this.config = config;
     this.log = log;
     this.api = api;
 
     // Perform validation on the configuration passed into us and set defaults if not present
+    this.config = processConfig(config, this.log);
+    this.#connections = buildConnections(this.config);
 
-    // Build our accounts connection object. Allows us to have multiple diffent account connections under the one accessory
-    Object.keys(this.config).forEach((key) => {
-      if (this.config[key]?.access_token !== undefined && this.config[key].access_token !== '') {
-        // Nest account connection, assign a random UUID for each connection
-        this.#connections[crypto.randomUUID()] = {
-          type: NestAccfactory.NestAccount,
-          authorised: false,
-          access_token: this.config[key].access_token,
-          fieldTest: this.config[key]?.fieldTest === true,
-          referer: this.config[key]?.fieldTest === true ? 'home.ft.nest.com' : 'home.nest.com',
-          restAPIHost: this.config[key]?.fieldTest === true ? 'home.ft.nest.com' : 'home.nest.com',
-          cameraAPIHost: this.config[key]?.fieldTest === true ? 'camera.home.ft.nest.com' : 'camera.home.nest.com',
-          protobufAPIHost: this.config[key]?.fieldTest === true ? 'grpc-web.ft.nest.com' : 'grpc-web.production.nest.com',
-        };
-      }
-      if (
-        this.config[key]?.issuetoken !== undefined &&
-        this.config[key].issuetoken !== '' &&
-        this.config[key]?.cookie !== undefined &&
-        this.config[key].cookie !== ''
-      ) {
-        // Google account connection, assign a random UUID for each connection
-        this.#connections[crypto.randomUUID()] = {
-          type: NestAccfactory.GoogleAccount,
-          authorised: false,
-          issuetoken: this.config[key].issuetoken,
-          cookie: this.config[key].cookie,
-          fieldTest: this.config[key]?.fieldTest === true,
-          referer: this.config[key]?.fieldTest === true ? 'home.ft.nest.com' : 'home.nest.com',
-          restAPIHost: this.config[key]?.fieldTest === true ? 'home.ft.nest.com' : 'home.nest.com',
-          cameraAPIHost: this.config[key]?.fieldTest === true ? 'camera.home.ft.nest.com' : 'camera.home.nest.com',
-          protobufAPIHost: this.config[key]?.fieldTest === true ? 'grpc-web.ft.nest.com' : 'grpc-web.production.nest.com',
-        };
-      }
-    });
-
-    // If we don't have either a Nest access_token and/or a Google issuetoken/cookie, return back.
+    // Check for valid connections, either a Nest and/or Google one specified. Otherwise, return back.
     if (Object.keys(this.#connections).length === 0) {
-      this?.log?.error && this.log.error('No connections have been specified in the JSON configuration. Please review');
+      this?.log?.error?.('No connections have been specified in the JSON configuration. Please review');
       return;
     }
 
-    if (typeof this.config?.options !== 'object') {
-      this.config.options = {};
-    }
+    eventEmitter?.on?.('didFinishLaunching', async () => {
+      // We got notified that Homebridge (or Docker) has finished loading
 
-    this.config.options.eveHistory = this.config.options?.eveHistory === true;
-    this.config.options.elevation = isNaN(this.config.options?.elevation) === false ? Number(this.config.options.elevation) : 0;
-    this.config.options.weather = this.config.options?.weather === true;
-    this.config.options.hksv = this.config.options?.hksv === true;
-
-    // Controls what APIs we use, default is to use both REST and protobuf APIs
-    this.config.options.restAPI = this.config.options?.restAPI === true || this.config.options?.restAPI === undefined;
-    this.config.options.protobufAPI = this.config.options?.protobufAPI === true || this.config.options?.protobufAPI === undefined;
-
-    // Get configuration for max number of concurrent 'live view' streams. For HomeKit Secure Video, this will always be 1
-    this.config.options.maxStreams =
-      isNaN(this.config.options?.maxStreams) === false && this.deviceData?.hksv === false
-        ? Number(this.config.options.maxStreams)
-        : this.deviceData?.hksv === true
-          ? 1
-          : 2;
-
-    // Check if a ffmpeg binary exist via a specific path in configuration OR /usr/local/bin
-    this.config.options.ffmpeg = {};
-    this.config.options.ffmpeg.debug = this.config.options?.ffmpegDebug === true;
-    this.config.options.ffmpeg.binary = path.resolve(
-      typeof this.config.options?.ffmpegPath === 'string' && this.config.options.ffmpegPath !== ''
-        ? this.config.options.ffmpegPath
-        : '/usr/local/bin',
-    );
+      // Load device support modules from the plugins folder if not already done
+      this.#deviceModules = await loadDeviceModules(this.log, 'plugins');
 
-    // If the path doesn't include 'ffmpeg' on the end, we'll add it here
-    if (this.config.options.ffmpeg.binary.endsWith('/ffmpeg') === false) {
-      this.config.options.ffmpeg.binary = this.config.options.ffmpeg.binary + '/ffmpeg';
-    }
+      // Start reconnect loop per connection with backoff for failed tries
+      // This also initiates both Nest and Protobuf subscribes
+      for (const uuid of Object.keys(this.#connections)) {
+        let reconnectDelay = 15000;
 
-    this.config.options.ffmpeg.version = undefined;
-    this.config.options.ffmpeg.libspeex = false;
-    this.config.options.ffmpeg.libopus = false;
-    this.config.options.ffmpeg.libx264 = false;
-    this.config.options.ffmpeg.libfdk_aac = false;
-
-    if (fs.existsSync(this.config.options.ffmpeg.binary) === false) {
-      if (this?.log?.warn) {
-        this.log.warn('Specified ffmpeg binary "%s" was not found', this.config.options.ffmpeg.binary);
-        this.log.warn('Stream video/recording from camera/doorbells will be unavailable');
-      }
-
-      // If we flag ffmpegPath as undefined, no video streaming/record support enabled for camers/doorbells
-      this.config.options.ffmpeg.binary = undefined;
-    }
-
-    // Process ffmpeg binary to see if we can use it
-    if (fs.existsSync(this.config.options.ffmpeg.binary) === true) {
-      let ffmpegProcess = child_process.spawnSync(this.config.options.ffmpeg.binary, ['-version'], {
-        env: process.env,
-      });
-      if (ffmpegProcess.stdout !== null) {
-        // Determine ffmpeg version
-        this.config.options.ffmpeg.version = ffmpegProcess.stdout
-          .toString()
-          .match(/(?:ffmpeg version:(\d+)\.)?(?:(\d+)\.)?(?:(\d+)\.\d+)(.*?)/gim)[0];
-
-        // Determine what libraries ffmpeg is compiled with
-        this.config.options.ffmpeg.libspeex = ffmpegProcess.stdout.toString().includes('--enable-libspeex') === true;
-        this.config.options.ffmpeg.libopus = ffmpegProcess.stdout.toString().includes('--enable-libopus') === true;
-        this.config.options.ffmpeg.libx264 = ffmpegProcess.stdout.toString().includes('--enable-libx264') === true;
-        this.config.options.ffmpeg.libfdk_aac = ffmpegProcess.stdout.toString().includes('--enable-libfdk-aac') === true;
-        if (
-          this.config.options.ffmpeg.version.localeCompare(FFMPEGVERSION, undefined, {
-            numeric: true,
-            sensitivity: 'case',
-            caseFirst: 'upper',
-          }) === -1 ||
-          this.config.options.ffmpeg.libspeex === false ||
-          this.config.options.ffmpeg.libopus === false ||
-          this.config.options.ffmpeg.libx264 === false ||
-          this.config.options.ffmpeg.libfdk_aac === false
-        ) {
-          this?.log?.warn &&
-            this.log.warn('ffmpeg binary "%s" does not meet the minimum support requirements', this.config.options.ffmpeg.binary);
-          if (
-            this.config.options.ffmpeg.version.localeCompare(FFMPEGVERSION, undefined, {
-              numeric: true,
-              sensitivity: 'case',
-              caseFirst: 'upper',
-            }) === -1
-          ) {
-            this?.log?.warn &&
-              this.log.warn(
-                'Minimum binary version is "%s", however the installed version is "%s"',
-                FFMPEGVERSION,
-                this.config.options.ffmpeg.version,
-              );
-            this?.log?.warn && this.log.warn('Stream video/recording from camera/doorbells will be unavailable');
+        const reconnectLoop = async () => {
+          if (this.#connections?.[uuid]?.authorised === false) {
+            try {
+              await this.#connect(uuid);
+              this.#subscribeNest(uuid, true);
+              this.#subscribeProtobuf(uuid, true);
+              // eslint-disable-next-line no-unused-vars
+            } catch (error) {
+              // Empty
+            }
 
-            this.config.options.ffmpeg.binary = undefined; // No ffmpeg since below min version
-          }
-          if (
-            this.config.options.ffmpeg.libspeex === false &&
-            this.config.options.ffmpeg.libx264 === true &&
-            this.config.options.ffmpeg.libfdk_aac === true
-          ) {
-            this?.log?.warn && this.log.warn('Missing libspeex in ffmpeg binary, talkback on certain camera/doorbells will be unavailable');
-          }
-          if (
-            this.config.options.ffmpeg.libx264 === true &&
-            this.config.options.ffmpeg.libfdk_aac === false &&
-            this.config.options.ffmpeg.libopus === false
-          ) {
-            this?.log?.warn &&
-              this.log.warn('Missing libfdk_aac and libopus in ffmpeg binary, audio from camera/doorbells will be unavailable');
-          }
-          if (this.config.options.ffmpeg.libx264 === true && this.config.options.ffmpeg.libfdk_aac === false) {
-            this?.log?.warn && this.log.warn('Missing libfdk_aac in ffmpeg binary, audio from camera/doorbells will be unavailable');
-          }
-          if (
-            this.config.options.ffmpeg.libx264 === true &&
-            this.config.options.ffmpeg.libfdk_aac === true &&
-            this.config.options.ffmpeg.libopus === false
-          ) {
-            this?.log?.warn &&
-              this.log.warn(
-                'Missing libopus in ffmpeg binary, audio (including talkback) from certain camera/doorbells will be unavailable',
-              );
+            reconnectDelay = this.#connections?.[uuid]?.authorised === true ? 15000 : Math.min(reconnectDelay * 2, 60000);
+          } else {
+            reconnectDelay = 15000;
           }
-          if (this.config.options.ffmpeg.libx264 === false) {
-            this?.log?.warn &&
-              this.log.warn('Missing libx264 in ffmpeg binary, stream video/recording from camera/doorbells will be unavailable');
 
-            this.config.options.ffmpeg.binary = undefined; // No ffmpeg since we do not have all the required libraries
-          }
-        }
-      }
-    }
+          setTimeout(reconnectLoop, reconnectDelay);
+        };
 
-    if (this.config.options.ffmpeg.binary !== undefined) {
-      this?.log?.success && this.log.success('Found valid ffmpeg binary in %s', this.config.options.ffmpeg.binary);
-    }
+        reconnectLoop();
+      }
+    });
 
-    if (this.api instanceof EventEmitter === true) {
-      this.api.on('didFinishLaunching', async () => {
-        // We got notified that Homebridge has finished loading, so we are ready to process
-        this.discoverDevices();
+    eventEmitter?.on?.('shutdown', async () => {
+      // We got notified that Homebridge is shutting down
+      // Perform cleanup of internal state
+      this.#eventEmitter?.removeAllListeners();
 
-        // We'll check connection status every 15 seconds. We'll also handle token expiry/refresh this way
-        clearInterval(this.#connectionTimer);
-        this.#connectionTimer = setInterval(this.discoverDevices.bind(this), 15000);
+      Object.values(this.#trackedDevices).forEach((device) => {
+        Object.values(device?.timers || {}).forEach((timer) => clearInterval(timer));
       });
 
-      this.api.on('shutdown', async () => {
-        // We got notified that Homebridge is shutting down
-        // Perform cleanup some internal cleaning up
-        this.#eventEmitter.removeAllListeners();
-        Object.values(this.#trackedDevices).forEach((value) => {
-          if (value?.timers !== undefined) {
-            Object.values(value?.timers).forEach((timers) => {
-              clearInterval(timers);
-            });
-          }
-        });
-        this.#trackedDevices = {};
-        clearInterval(this.#connectionTimer);
-        this.#connectionTimer = undefined;
-        this.#rawData = {};
-        this.#protobufRoot = null;
-        this.#eventEmitter = undefined;
-      });
-    }
+      this.#trackedDevices = {};
+      this.#rawData = {};
+      this.#protobufRoot = null;
+      this.#eventEmitter = undefined;
+    });
 
     // Setup event listeners for set/get calls from devices if not already done so
     this.#eventEmitter.addListener(HomeKitDevice.SET, (uuid, values) => {
-      this.#set(uuid, values);
+      this.#set(values);
     });
+
     this.#eventEmitter.addListener(HomeKitDevice.GET, async (uuid, values) => {
-      let results = await this.#get(uuid, values);
+      let results = await this.#get(values);
       // Send the results back to the device via a special event (only if still active)
-      if (this.#eventEmitter !== undefined) {
-        this.#eventEmitter.emit(HomeKitDevice.GET + '->' + uuid, results);
-      }
+      this.#eventEmitter?.emit?.(HomeKitDevice.GET + '->' + uuid, results);
     });
   }
 
   configureAccessory(accessory) {
     // This gets called from Homebridge each time it restores an accessory from its cache
-    this?.log?.info && this.log.info('Loading accessory from cache:', accessory.displayName);
+    this?.log?.info?.('Loading accessory from cache:', accessory.displayName);
 
     // add the restored accessory to the accessories cache, so we can track if it has already been registered
     this.cachedAccessories.push(accessory);
   }
 
-  async discoverDevices() {
-    Object.keys(this.#connections).forEach((uuid) => {
-      if (this.#connections[uuid].authorised === false) {
-        this.#connect(uuid).then(() => {
-          if (this.#connections[uuid].authorised === true && this.config.options?.restAPI === true) {
-            this.#subscribeREST(uuid, true);
-          }
-          if (this.#connections[uuid].authorised === true && this.config.options?.protobufAPI === true) {
-            this.#subscribeProtobuf(uuid, true);
-          }
-        });
-      }
-    });
-  }
-
-  async #connect(connectionUUID) {
-    if (typeof this.#connections?.[connectionUUID] === 'object') {
-      if (this.#connections[connectionUUID].type === NestAccfactory.GoogleAccount) {
+  async #connect(uuid) {
+    if (typeof this.#connections?.[uuid] === 'object') {
+      this?.log?.info?.(
+        'Performing authorisation for connection "%s" %s',
+        this.#connections[uuid].name,
+        this.#connections[uuid].fieldTest === true ? 'using field test endpoints' : '',
+      );
+      if (this.#connections[uuid].type === AccountType.Google) {
         // Google cookie method as refresh token method no longer supported by Google since October 2022
         // Instructions from homebridge_nest or homebridge_nest_cam to obtain this
-        this?.log?.info &&
-          this.log.info(
-            'Performing Google account authorisation ' +
-              (this.#connections[connectionUUID].fieldTest === true ? 'using field test endpoints' : ''),
-          );
+        this?.log?.debug?.('Performing authorisation using Google account for connection uuid "%s"', uuid);
 
-        await fetchWrapper('get', this.#connections[connectionUUID].issuetoken, {
+        await fetchWrapper('get', this.#connections[uuid].issuetoken, {
           headers: {
             referer: 'https://accounts.google.com/o/oauth2/iframe',
             'User-Agent': USERAGENT,
-            cookie: this.#connections[connectionUUID].cookie,
+            cookie: this.#connections[uuid].cookie,
             'Sec-Fetch-Mode': 'cors',
             'X-Requested-With': 'XmlHttpRequest',
           },
@@ -354,7 +166,7 @@ export default class NestAccfactory {
               'https://nestauthproxyservice-pa.googleapis.com/v1/issue_jwt',
               {
                 headers: {
-                  referer: 'https://' + this.#connections[connectionUUID].referer,
+                  referer: 'https://' + this.#connections[uuid].referer,
                   'User-Agent': USERAGENT,
                   Authorization: data.token_type + ' ' + data.access_token,
                   'Content-Type': 'application/x-www-form-urlencoded',
@@ -369,9 +181,9 @@ export default class NestAccfactory {
                 let googleToken = data.jwt;
                 let tokenExpire = Math.floor(new Date(data.claims.expirationTime).valueOf() / 1000); // Token expiry, should be 1hr
 
-                await fetchWrapper('get', 'https://' + this.#connections[connectionUUID].restAPIHost + '/session', {
+                await fetchWrapper('get', 'https://' + this.#connections[uuid].restAPIHost + '/session', {
                   headers: {
-                    referer: 'https://' + this.#connections[connectionUUID].referer,
+                    referer: 'https://' + this.#connections[uuid].referer,
                     'User-Agent': USERAGENT,
                     Authorization: 'Basic ' + googleToken,
                   },
@@ -379,65 +191,58 @@ export default class NestAccfactory {
                   .then((response) => response.json())
                   .then((data) => {
                     // Store successful connection details
-                    this.#connections[connectionUUID].authorised = true;
-                    this.#connections[connectionUUID].userID = data.userid;
-                    this.#connections[connectionUUID].transport_url = data.urls.transport_url;
-                    this.#connections[connectionUUID].weather_url = data.urls.weather_url;
-                    this.#connections[connectionUUID].token = googleToken;
-                    this.#connections[connectionUUID].cameraAPI = {
+                    this.#connections[uuid].authorised = true;
+                    this.#connections[uuid].userID = data.userid;
+                    this.#connections[uuid].transport_url = data.urls.transport_url;
+                    this.#connections[uuid].weather_url = data.urls.weather_url;
+                    this.#connections[uuid].token = googleToken;
+                    this.#connections[uuid].cameraAPI = {
                       key: 'Authorization',
                       value: 'Basic ', // NOTE: extra space required
                       token: googleToken,
                       oauth2: googleOAuth2Token,
+                      fieldTest: this.#connections[uuid]?.fieldTest === true,
                     };
 
                     // Set timeout for token expiry refresh
-                    clearTimeout(this.#connections[connectionUUID].timer);
-                    this.#connections[connectionUUID].timer = setTimeout(
+                    clearTimeout(this.#connections[uuid].timer);
+                    this.#connections[uuid].timer = setTimeout(
                       () => {
-                        this?.log?.info && this.log.info('Performing periodic token refresh for Google account');
-                        this.#connect(connectionUUID);
+                        this?.log?.info?.('Performing periodic token refresh for connection "%s"', this.#connections[uuid].name);
+                        this.#connect(uuid);
                       },
                       (tokenExpire - Math.floor(Date.now() / 1000) - 60) * 1000,
                     ); // Refresh just before token expiry
 
-                    this?.log?.success && this.log.success('Successfully authorised using Google account');
+                    this?.log?.success?.('Successfully authorised connection "%s"', this.#connections[uuid].name);
                   });
               });
           })
           // eslint-disable-next-line no-unused-vars
           .catch((error) => {
             // The token we used to obtained a Nest session failed, so overall authorisation failed
-            this.#connections[connectionUUID].authorised = false;
-            this?.log?.debug &&
-              this.log.debug(
-                'Failed to connect to gateway using credential details for connection uuid "%s". A periodic retry event will be triggered',
-                connectionUUID,
-              );
-            this?.log?.error && this.log.error('Authorisation failed using Google account');
+            this.#connections[uuid].authorised = false;
+            this?.log?.debug?.('Failed to connect using credential details for connection uuid "%s"', uuid);
+            this?.log?.error?.('Authorisation failed on connection "%s"', this.#connections[uuid].name);
           });
       }
 
-      if (this.#connections[connectionUUID].type === NestAccfactory.NestAccount) {
+      if (this.#connections[uuid].type === AccountType.Nest) {
         // Nest access token method. Get WEBSITE2 cookie for use with camera API calls if needed later
-        this?.log?.info &&
-          this.log.info(
-            'Performing Nest account authorisation ' +
-              (this.#connections[connectionUUID].fieldTest === true ? 'using field test endpoints' : ''),
-          );
+        this?.log?.debug?.('Performing authorisation using Nest account for connection uuid "%s"', uuid);
 
         await fetchWrapper(
           'post',
-          'https://webapi.' + this.#connections[connectionUUID].cameraAPIHost + '/api/v1/login.login_nest',
+          'https://webapi.' + this.#connections[uuid].cameraAPIHost + '/api/v1/login.login_nest',
           {
             withCredentials: true,
             headers: {
-              referer: 'https://' + this.#connections[connectionUUID].referer,
+              referer: 'https://' + this.#connections[uuid].referer,
               'User-Agent': USERAGENT,
               'Content-Type': 'application/x-www-form-urlencoded',
             },
           },
-          Buffer.from('access_token=' + this.#connections[connectionUUID].access_token, 'utf8'),
+          Buffer.from('access_token=' + this.#connections[uuid].access_token, 'utf8'),
         )
           .then((response) => response.json())
           .then(async (data) => {
@@ -447,53 +252,58 @@ export default class NestAccfactory {
 
             let nestToken = data.items[0].session_token;
 
-            await fetchWrapper('get', 'https://' + this.#connections[connectionUUID].restAPIHost + '/session', {
+            await fetchWrapper('get', 'https://' + this.#connections[uuid].restAPIHost + '/session', {
               headers: {
-                referer: 'https://' + this.#connections[connectionUUID].referer,
+                referer: 'https://' + this.#connections[uuid].referer,
                 'User-Agent': USERAGENT,
-                Authorization: 'Basic ' + this.#connections[connectionUUID].access_token,
+                Authorization: 'Basic ' + this.#connections[uuid].access_token,
               },
             })
               .then((response) => response.json())
               .then((data) => {
                 // Store successful connection details
-                this.#connections[connectionUUID].authorised = true;
-                this.#connections[connectionUUID].userID = data.userid;
-                this.#connections[connectionUUID].transport_url = data.urls.transport_url;
-                this.#connections[connectionUUID].weather_url = data.urls.weather_url;
-                this.#connections[connectionUUID].token = this.#connections[connectionUUID].access_token;
-                this.#connections[connectionUUID].cameraAPI = {
+                this.#connections[uuid].authorised = true;
+                this.#connections[uuid].userID = data.userid;
+                this.#connections[uuid].transport_url = data.urls.transport_url;
+                this.#connections[uuid].weather_url = data.urls.weather_url;
+                this.#connections[uuid].token = this.#connections[uuid].access_token;
+                this.#connections[uuid].cameraAPI = {
                   key: 'cookie',
-                  value: this.#connections[connectionUUID].fieldTest === true ? 'website_ft=' : 'website_2=',
+                  value: this.#connections[uuid].fieldTest === true ? 'website_ft=' : 'website_2=',
                   token: nestToken,
+                  fieldTest: this.#connections[uuid]?.fieldTest === true,
                 };
 
                 // Set timeout for token expiry refresh
-                clearTimeout(this.#connections[connectionUUID].timer);
-                this.#connections[connectionUUID].timer = setTimeout(
+                clearTimeout(this.#connections[uuid].timer);
+                this.#connections[uuid].timer = setTimeout(
                   () => {
-                    this?.log?.info && this.log.info('Performing periodic token refresh for Nest account');
-                    this.#connect(connectionUUID);
+                    this?.log?.info?.('Performing periodic token refresh for connection "%s"', this.#connections[uuid].name);
+                    this.#connect(uuid);
                   },
                   1000 * 3600 * 24,
                 ); // Refresh token every 24hrs
 
-                this?.log?.success && this.log.success('Successfully authorised using Nest account');
+                this?.log?.success?.('Successfully authorised connection "%s"', this.#connections[uuid].name);
               });
           })
           // eslint-disable-next-line no-unused-vars
           .catch((error) => {
             // The token we used to obtained a Nest session failed, so overall authorisation failed
-            this.#connections[connectionUUID].authorised = false;
-            this?.log?.debug && this.log.debug('Failed to connect using credential details for connection uuid "%s"', connectionUUID);
-            this?.log?.error && this.log.error('Authorisation failed using Nest account');
+            this.#connections[uuid].authorised = false;
+            this?.log?.debug?.('Failed to connect using credential details for connection uuid "%s"', uuid);
+            this?.log?.error?.('Authorisation failed on connection "%s"', this.#connections[uuid].name);
           });
       }
     }
   }
 
-  async #subscribeREST(connectionUUID, fullRefresh) {
-    if (typeof this.#connections?.[connectionUUID] !== 'object' || this.#connections?.[connectionUUID]?.authorised !== true) {
+  async #subscribeNest(uuid, fullRefresh) {
+    if (
+      typeof this.#connections?.[uuid] !== 'object' ||
+      this.#connections?.[uuid]?.authorised === false ||
+      this.config?.options?.useNestAPI === false
+    ) {
       // Not a valid connection object and/or we're not authorised
       return;
     }
@@ -513,25 +323,20 @@ export default class NestAccfactory {
       'topaz',
       'widget_track',
       'quartz',
+      'occupancy',
     ];
 
-    // By default, setup for a full data read from the REST API
-    let subscribeURL =
-      'https://' +
-      this.#connections[connectionUUID].restAPIHost +
-      '/api/0.1/user/' +
-      this.#connections[connectionUUID].userID +
-      '/app_launch';
+    // By default, setup for a full data read from the Nest API
+    let subscribeURL = 'https://' + this.#connections[uuid].restAPIHost + '/api/0.1/user/' + this.#connections[uuid].userID + '/app_launch';
     let subscribeJSONData = { known_bucket_types: REQUIREDBUCKETS, known_bucket_versions: [] };
 
     if (fullRefresh === false) {
-      // We have data stored from this REST API, so setup read using known object
-      subscribeURL = this.#connections[connectionUUID].transport_url + '/v6/subscribe';
+      // We have data stored from this Nest API, so setup read using known object
+      subscribeURL = this.#connections[uuid].transport_url + '/v6/subscribe';
       subscribeJSONData = { objects: [] };
-
       Object.entries(this.#rawData)
         // eslint-disable-next-line no-unused-vars
-        .filter(([object_key, object]) => object.source === NestAccfactory.DataSource.REST && object.connection === connectionUUID)
+        .filter(([object_key, object]) => object.source === DATASOURCE.NestAPI && object.connection === uuid)
         .forEach(([object_key, object]) => {
           subscribeJSONData.objects.push({
             object_key: object_key,
@@ -542,7 +347,7 @@ export default class NestAccfactory {
     }
 
     if (fullRefresh === true) {
-      this?.log?.debug && this.log.debug('Starting REST API subscribe for connection uuid "%s"', connectionUUID);
+      this?.log?.debug?.('Starting Nest API subscribe for connection uuid "%s"', uuid);
     }
 
     fetchWrapper(
@@ -550,9 +355,9 @@ export default class NestAccfactory {
       subscribeURL,
       {
         headers: {
-          referer: 'https://' + this.#connections[connectionUUID].referer,
+          referer: 'https://' + this.#connections[uuid].referer,
           'User-Agent': USERAGENT,
-          Authorization: 'Basic ' + this.#connections[connectionUUID].token,
+          Authorization: 'Basic ' + this.#connections[uuid].token,
         },
         keepalive: true,
         //timeout: (5 * 60000),
@@ -585,12 +390,7 @@ export default class NestAccfactory {
               ) {
                 value.value.weather = this.#rawData[value.object_key].value.weather;
               }
-              value.value.weather = await this.#getWeatherData(
-                connectionUUID,
-                value.object_key,
-                value.value.latitude,
-                value.value.longitude,
-              );
+              value.value.weather = await this.#getWeather(uuid, value.object_key, value.value.latitude, value.value.longitude);
 
               // Check for changes in the swarm property. This seems indicate changes in devices
               if (typeof this.#rawData[value.object_key] === 'object') {
@@ -611,78 +411,70 @@ export default class NestAccfactory {
                   ? this.#rawData[value.object_key].value.properties
                   : [];
 
-              await fetchWrapper(
-                'get',
-                'https://webapi.' +
-                  this.#connections[connectionUUID].cameraAPIHost +
-                  '/api/cameras.get_with_properties?uuid=' +
-                  value.object_key.split('.')[1],
-                {
-                  headers: {
-                    referer: 'https://' + this.#connections[connectionUUID].referer,
-                    'User-Agent': USERAGENT,
-                    [this.#connections[connectionUUID].cameraAPI.key]:
-                      this.#connections[connectionUUID].cameraAPI.value + this.#connections[connectionUUID].cameraAPI.token,
+              try {
+                let response = await fetchWrapper(
+                  'get',
+                  'https://webapi.' +
+                    this.#connections[uuid].cameraAPIHost +
+                    '/api/cameras.get_with_properties?uuid=' +
+                    value.object_key.split('.')[1],
+                  {
+                    headers: {
+                      referer: 'https://' + this.#connections[uuid].referer,
+                      'User-Agent': USERAGENT,
+                      [this.#connections[uuid].cameraAPI.key]:
+                        this.#connections[uuid].cameraAPI.value + this.#connections[uuid].cameraAPI.token,
+                    },
+                    timeout: NESTAPITIMEOUT,
                   },
-                  timeout: NESTAPITIMEOUT,
-                },
-              )
-                .then((response) => response.json())
-                .then((data) => {
-                  value.value.properties = data.items[0].properties;
-                })
-                .catch((error) => {
-                  if (
-                    error?.cause !== undefined &&
-                    JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false &&
-                    this?.log?.debug
-                  ) {
-                    this.log.debug('REST API had error retrieving camera/doorbell details during subscribe. Error was "%s"', error?.code);
-                  }
-                });
+                );
+                let data = await response.json();
+                value.value.properties = data.items[0].properties;
+              } catch (error) {
+                if (error?.cause !== undefined && String(error.cause).toUpperCase().includes('TIMEOUT') === false) {
+                  this?.log?.debug?.(
+                    'Nest API had error retrieving camera/doorbell details during subscribe. Error was "%s"',
+                    error?.code ?? String(error),
+                  );
+                }
+              }
 
               value.value.activity_zones =
                 typeof this.#rawData[value.object_key]?.value?.activity_zones === 'object'
                   ? this.#rawData[value.object_key].value.activity_zones
                   : [];
 
-              await fetchWrapper('get', value.value.nexus_api_http_server_url + '/cuepoint_category/' + value.object_key.split('.')[1], {
-                headers: {
-                  referer: 'https://' + this.#connections[connectionUUID].referer,
-                  'User-Agent': USERAGENT,
-                  [this.#connections[connectionUUID].cameraAPI.key]:
-                    this.#connections[connectionUUID].cameraAPI.value + this.#connections[connectionUUID].cameraAPI.token,
-                },
-                timeout: NESTAPITIMEOUT,
-              })
-                .then((response) => response.json())
-                .then((data) => {
-                  let zones = [];
-                  data.forEach((zone) => {
-                    if (zone.type.toUpperCase() === 'ACTIVITY' || zone.type.toUpperCase() === 'REGION') {
-                      zones.push({
-                        id: zone.id === 0 ? 1 : zone.id,
-                        name: makeHomeKitName(zone.label),
-                        hidden: zone.hidden === true,
-                        uri: zone.nexusapi_image_uri,
-                      });
-                    }
-                  });
-
-                  value.value.activity_zones = zones;
-                })
-                .catch((error) => {
-                  if (
-                    error?.cause !== undefined &&
-                    JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false &&
-                    this?.log?.debug
-                  ) {
-                    this.log.debug(
-                      'REST API had error retrieving camera/doorbell activity zones during subscribe. Error was "%s"',
-                      error?.code,
-                    );
-                  }
-                });
+              try {
+                let response = await fetchWrapper(
+                  'get',
+                  value.value.nexus_api_http_server_url + '/cuepoint_category/' + value.object_key.split('.')[1],
+                  {
+                    headers: {
+                      referer: 'https://' + this.#connections[uuid].referer,
+                      'User-Agent': USERAGENT,
+                      [this.#connections[uuid].cameraAPI.key]:
+                        this.#connections[uuid].cameraAPI.value + this.#connections[uuid].cameraAPI.token,
+                    },
+                    timeout: NESTAPITIMEOUT,
+                  },
+                );
+                let data = await response.json();
+                value.value.activity_zones = data
+                  .filter((zone) => zone?.type?.toUpperCase() === 'ACTIVITY' || zone?.type?.toUpperCase() === 'REGION')
+                  .map((zone) => ({
+                    id: zone.id === 0 ? 1 : zone.id,
+                    name: makeHomeKitName(zone.label),
+                    hidden: zone.hidden === true,
+                    uri: zone.nexusapi_image_uri,
+                  }));
+              } catch (error) {
+                if (error?.cause !== undefined && String(error.cause).toUpperCase().includes('TIMEOUT') === false) {
+                  this?.log?.debug?.(
+                    'Nest API had error retrieving camera/doorbell activity zones during subscribe. Error was "%s"',
+                    error?.code ?? String(error),
+                  );
+                }
+              }
             }
 
             if (value.object_key.startsWith('buckets.') === true) {
@@ -693,7 +485,7 @@ export default class NestAccfactory {
                 // Check for added objects
                 value.value.buckets.map((object_key) => {
                   if (this.#rawData[value.object_key].value.buckets.includes(object_key) === false) {
-                    // Since this is an added object to the raw REST API structure, we need to do a full read of the data
+                    // Since this is an added object to the raw Nest API structure, we need to do a full read of the data
                     fullRefresh = true;
                   }
                 });
@@ -719,13 +511,11 @@ export default class NestAccfactory {
                         });
 
                         // Send removed notice onto HomeKit device for it to process
-                        if (this.#eventEmitter !== undefined) {
-                          this.#eventEmitter.emit(
-                            this.#trackedDevices[this.#rawData[object_key].value.serial_number].uuid,
-                            HomeKitDevice.REMOVE,
-                            {},
-                          );
-                        }
+                        this.#eventEmitter?.emit?.(
+                          this.#trackedDevices[this.#rawData[object_key].value.serial_number].uuid,
+                          HomeKitDevice.REMOVE,
+                          {},
+                        );
 
                         // Finally, remove from tracked devices
                         delete this.#trackedDevices[this.#rawData[object_key].value.serial_number];
@@ -737,17 +527,17 @@ export default class NestAccfactory {
               }
             }
 
-            // Store or update the date in our internally saved raw REST API data
+            // Store or update the date in our internally saved raw Nest API data
             if (typeof this.#rawData[value.object_key] === 'undefined') {
               this.#rawData[value.object_key] = {};
               this.#rawData[value.object_key].object_revision = value.object_revision;
               this.#rawData[value.object_key].object_timestamp = value.object_timestamp;
-              this.#rawData[value.object_key].connection = connectionUUID;
-              this.#rawData[value.object_key].source = NestAccfactory.DataSource.REST;
+              this.#rawData[value.object_key].connection = uuid;
+              this.#rawData[value.object_key].source = DATASOURCE.NestAPI;
               this.#rawData[value.object_key].value = {};
             }
 
-            // Finally, update our internal raw REST API data with the new values
+            // Finally, update our internal raw Nest API data with the new values
             this.#rawData[value.object_key].object_revision = value.object_revision; // Used for future subscribes
             this.#rawData[value.object_key].object_timestamp = value.object_timestamp; // Used for future subscribes
             for (const [fieldKey, fieldValue] of Object.entries(value.value)) {
@@ -759,55 +549,57 @@ export default class NestAccfactory {
         await this.#processPostSubscribe();
       })
       .catch((error) => {
-        if (error?.cause !== undefined && JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false && this?.log?.debug) {
-          this.log.debug('REST API had an error performing subscription with connection uuid "%s"', connectionUUID);
-          this.log.debug('Error was "%s"', error);
+        if (
+          error?.cause === undefined ||
+          (typeof error.cause === 'object' && String(error.cause).toUpperCase().includes('TIMEOUT') === false)
+        ) {
+          this?.log?.debug?.(
+            'Nest API had an error performing subscription with connection uuid "%s"',
+            uuid,
+            error?.message ?? String(error),
+          );
+          this?.log?.debug?.('Restarting Nest API subscription for connection uuid "%s"', uuid);
         }
       })
       .finally(() => {
-        this?.log?.debug && this.log.debug('Restarting REST API subscribe for connection uuid "%s"', connectionUUID);
-        setTimeout(this.#subscribeREST.bind(this, connectionUUID, fullRefresh), 1000);
+        setTimeout(() => this.#subscribeNest(uuid, fullRefresh), 1000);
       });
   }
 
-  async #subscribeProtobuf(connectionUUID, firstRun) {
-    if (typeof this.#connections?.[connectionUUID] !== 'object' || this.#connections?.[connectionUUID]?.authorised !== true) {
+  async #subscribeProtobuf(uuid, firstRun) {
+    if (
+      typeof this.#connections?.[uuid] !== 'object' ||
+      this.#connections?.[uuid]?.authorised === false ||
+      this.config?.options?.useGoogleAPI === false
+    ) {
       // Not a valid connection object and/or we're not authorised
       return;
     }
 
     const calculate_message_size = (inputBuffer) => {
-      // First byte in the is a tag type??
-      // Following is a varint type
-      // After varint size, is the buffer content
       let varint = 0;
-      let bufferPos = 0;
-      let currentByte;
-
-      for (;;) {
-        currentByte = inputBuffer[bufferPos + 1]; // Offset in buffer + 1 to skip over starting tag
-        varint |= (currentByte & 0x7f) << (bufferPos * 7);
-        bufferPos += 1;
-        if (bufferPos > 5) {
-          throw new Error('VarInt exceeds allowed bounds.');
-        }
-        if ((currentByte & 0x80) !== 0x80) {
-          break;
+      let shift = 0;
+
+      for (let i = 1; i <= 5; i++) {
+        // Start at index 1 (skip tag byte)
+        let byte = inputBuffer[i];
+        varint |= (byte & 0x7f) << shift;
+        if ((byte & 0x80) === 0) {
+          return varint + i + 1; // +1 to include initial tag byte
         }
+        shift += 7;
       }
 
-      // Return length of message in buffer
-      return varint + bufferPos + 1;
+      throw new Error('VarInt exceeds allowed bounds.');
     };
 
-    const traverseTypes = (currentTrait, callback) => {
-      if (currentTrait instanceof protobuf.Type) {
-        callback(currentTrait);
+    const traverseTypes = (trait, callback) => {
+      if (trait instanceof protobuf.Type === true) {
+        callback(trait);
       }
-      if (currentTrait.nestedArray) {
-        currentTrait.nestedArray.map((trait) => {
-          traverseTypes(trait, callback);
-        });
+
+      for (const nested of trait && trait.nestedArray ? trait.nestedArray : []) {
+        traverseTypes(nested, callback);
       }
     };
 
@@ -817,13 +609,12 @@ export default class NestAccfactory {
       protobuf.configure();
       this.#protobufRoot = protobuf.loadSync(path.resolve(__dirname + '/protobuf/root.proto'));
       if (this.#protobufRoot !== null) {
-        this?.log?.debug && this.log.debug('Loaded protobuf support files for Protobuf API');
+        this?.log?.debug?.('Loaded protobuf support files for Protobuf API');
       }
     }
 
     if (this.#protobufRoot === null) {
-      this?.log?.warn &&
-        this.log.warn('Failed to loaded Protobuf API support files. This will cause certain Nest/Google devices to be un-supported');
+      this?.log?.warn?.('Failed to loaded Protobuf API support files. This will cause certain Nest/Google devices to be un-supported');
       return;
     }
 
@@ -834,15 +625,15 @@ export default class NestAccfactory {
     let observeRequest = this.#protobufRoot.lookup('nestlabs.gateway.v2.ObserveRequest');
     if (traitTypeObserveParam !== null && observeRequest !== null) {
       traverseTypes(this.#protobufRoot, (type) => {
-        // We only want to have certain trait'families' in our observe reponse we are building
+        // We only want to have certain trait 'families' in our observe reponse we are building
         // This also depends on the account type we connected with
         // Nest accounts cannot observe camera/doorbell product traits
         if (
-          (this.#connections[connectionUUID].type === NestAccfactory.NestAccount &&
+          (this.#connections[uuid].type === AccountType.Nest &&
             type.fullName.startsWith('.nest.trait.product.camera') === false &&
             type.fullName.startsWith('.nest.trait.product.doorbell') === false &&
             (type.fullName.startsWith('.nest.trait') === true || type.fullName.startsWith('.weave.') === true)) ||
-          (this.#connections[connectionUUID].type === NestAccfactory.GoogleAccount &&
+          (this.#connections[uuid].type === AccountType.Google &&
             (type.fullName.startsWith('.nest.trait') === true ||
               type.fullName.startsWith('.weave.') === true ||
               type.fullName.startsWith('.google.trait.product.camera') === true))
@@ -854,17 +645,17 @@ export default class NestAccfactory {
     }
 
     if (firstRun === true) {
-      this?.log?.debug && this.log.debug('Starting Protobuf API trait observe for connection uuid "%s"', connectionUUID);
+      this?.log?.debug?.('Starting Protobuf API trait observe for connection uuid "%s"', uuid);
     }
 
     fetchWrapper(
       'post',
-      'https://' + this.#connections[connectionUUID].protobufAPIHost + '/nestlabs.gateway.v2.GatewayService/Observe',
+      'https://' + this.#connections[uuid].protobufAPIHost + '/nestlabs.gateway.v2.GatewayService/Observe',
       {
         headers: {
-          referer: 'https://' + this.#connections[connectionUUID].referer,
+          referer: 'https://' + this.#connections[uuid].referer,
           'User-Agent': USERAGENT,
-          Authorization: 'Basic ' + this.#connections[connectionUUID].token,
+          Authorization: 'Basic ' + this.#connections[uuid].token,
           'Content-Type': 'application/x-protobuf',
           'X-Accept-Content-Transfer-Encoding': 'binary',
           'X-Accept-Response-Streaming': 'true',
@@ -929,13 +720,11 @@ export default class NestAccfactory {
                       }
 
                       // Send removed notice onto HomeKit device for it to process
-                      if (this.#eventEmitter !== undefined) {
-                        this.#eventEmitter.emit(
-                          this.#trackedDevices[this.#rawData[resource.resourceId].value.device_identity.serialNumber].uuid,
-                          HomeKitDevice.REMOVE,
-                          {},
-                        );
-                      }
+                      this.#eventEmitter?.emit?.(
+                        this.#trackedDevices[this.#rawData[resource.resourceId].value.device_identity.serialNumber].uuid,
+                        HomeKitDevice.REMOVE,
+                        {},
+                      );
 
                       // Finally, remove from tracked devices
                       delete this.#trackedDevices[this.#rawData[resource.resourceId].value.device_identity.serialNumber];
@@ -955,8 +744,8 @@ export default class NestAccfactory {
                 decodedMessage.observeResponse[0].traitStates.map(async (trait) => {
                   if (typeof this.#rawData[trait.traitId.resourceId] === 'undefined') {
                     this.#rawData[trait.traitId.resourceId] = {};
-                    this.#rawData[trait.traitId.resourceId].connection = connectionUUID;
-                    this.#rawData[trait.traitId.resourceId].source = NestAccfactory.DataSource.PROTOBUF;
+                    this.#rawData[trait.traitId.resourceId].connection = uuid;
+                    this.#rawData[trait.traitId.resourceId].source = DATASOURCE.ProtobufAPI;
                     this.#rawData[trait.traitId.resourceId].value = {};
                   }
                   this.#rawData[trait.traitId.resourceId]['value'][trait.traitId.traitLabel] =
@@ -966,15 +755,15 @@ export default class NestAccfactory {
                   delete this.#rawData[trait.traitId.resourceId]['value'][trait.traitId.traitLabel]['@type'];
 
                   // If we have structure location details and associated geo-location details, get the weather data for the location
-                  // We'll store this in the object key/value as per REST API
+                  // We'll store this in the object key/value as per Nest API
                   if (
                     trait.traitId.resourceId.startsWith('STRUCTURE_') === true &&
                     trait.traitId.traitLabel === 'structure_location' &&
                     isNaN(trait.patch.values?.geoCoordinate?.latitude) === false &&
                     isNaN(trait.patch.values?.geoCoordinate?.longitude) === false
                   ) {
-                    this.#rawData[trait.traitId.resourceId].value.weather = await this.#getWeatherData(
-                      connectionUUID,
+                    this.#rawData[trait.traitId.resourceId].value.weather = await this.#getWeather(
+                      uuid,
                       trait.traitId.resourceId,
                       Number(trait.patch.values.geoCoordinate.latitude),
                       Number(trait.patch.values.geoCoordinate.longitude),
@@ -989,15 +778,20 @@ export default class NestAccfactory {
         }
       })
       .catch((error) => {
-        if (error?.cause !== undefined && JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false && this?.log?.debug) {
-          this.log.debug('Protobuf API had an error performing trait observe with connection uuid "%s"', connectionUUID);
-          this.log.debug('Error was "%s"', error);
+        if (
+          error?.cause === undefined ||
+          (typeof error.cause === 'object' && String(error.cause).toUpperCase().includes('TIMEOUT') === false)
+        ) {
+          this?.log?.debug?.(
+            'Protobuf API had an error performing trait observe with connection uuid "%s". Error: "%s"',
+            uuid,
+            error?.message ?? String(error),
+          );
+          this?.log?.debug?.('Restarting Protobuf API trait observe for connection uuid "%s"', uuid);
         }
       })
-
       .finally(() => {
-        this?.log?.debug && this.log.debug('Restarting Protobuf API trait observe for connection uuid "%s"', connectionUUID);
-        setTimeout(this.#subscribeProtobuf.bind(this, connectionUUID, false), 1000);
+        setTimeout(() => this.#subscribeProtobuf(uuid, false), 1000);
       });
   }
 
@@ -1005,79 +799,44 @@ export default class NestAccfactory {
     Object.values(this.#processData('')).forEach((deviceData) => {
       if (this.#trackedDevices?.[deviceData?.serialNumber] === undefined && deviceData?.excluded === true) {
         // We haven't tracked this device before (ie: should be a new one) and but its excluded
-        this?.log?.warn && this.log.warn('Device "%s" is ignored due to it being marked as excluded', deviceData.description);
+        this?.log?.warn?.('Device "%s" is ignored due to it being marked as excluded', deviceData.description);
 
         // Track this device even though its excluded
         this.#trackedDevices[deviceData.serialNumber] = {
-          uuid: undefined,
+          uuid: HomeKitDevice.generateUUID(HomeKitDevice.PLUGIN_NAME, this.api, deviceData.serialNumber),
           rawDataUuid: deviceData.nest_google_uuid,
           source: undefined,
+          timers: undefined,
           exclude: true,
         };
+
+        // If we're running under Homebridge, and the device is now marked as excluded and present in accessory cache
+        // Then we'll unregister it from the Homebridge platform
+        if (typeof this?.api?.unregisterPlatformAccessories === 'function') {
+          let accessory = this.cachedAccessories.find(
+            (accessory) => accessory?.UUID === this.#trackedDevices[deviceData.serialNumber].uuid,
+          );
+          if (accessory !== undefined && typeof accessory === 'object') {
+            this.api.unregisterPlatformAccessories(HomeKitDevice.PLUGIN_NAME, HomeKitDevice.PLATFORM_NAME, [accessory]);
+          }
+        }
       }
 
       if (this.#trackedDevices?.[deviceData?.serialNumber] === undefined && deviceData?.excluded === false) {
         // We haven't tracked this device before (ie: should be a new one) and its not excluded
         // so create the required HomeKit accessories based upon the device data
-        if (deviceData.device_type === NestAccfactory.DeviceType.THERMOSTAT && typeof NestThermostat === 'function') {
-          // Nest Thermostat(s) - Categories.THERMOSTAT = 9
-          let tempDevice = new NestThermostat(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
-          tempDevice.add('Nest Thermostat', 9, true);
-          // Track this device once created
-          this.#trackedDevices[deviceData.serialNumber] = {
-            uuid: tempDevice.uuid,
-            rawDataUuid: deviceData.nest_google_uuid,
-            source: undefined,
-          };
-        }
-
-        if (deviceData.device_type === NestAccfactory.DeviceType.TEMPSENSOR && typeof NestTemperatureSensor === 'function') {
-          // Nest Temperature Sensor - Categories.SENSOR = 10;
-          let tempDevice = new NestTemperatureSensor(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
-          tempDevice.add('Nest Temperature Sensor', 10, true);
-          // Track this device once created
-          this.#trackedDevices[deviceData.serialNumber] = {
-            uuid: tempDevice.uuid,
-            rawDataUuid: deviceData.nest_google_uuid,
-            source: undefined,
-          };
-        }
-
-        if (deviceData.device_type === NestAccfactory.DeviceType.SMOKESENSOR && typeof NestProtect === 'function') {
-          // Nest Protect(s) - Categories.SENSOR = 10
-          let tempDevice = new NestProtect(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
-          tempDevice.add('Nest Protect', 10, true);
-          // Track this device once created
-          this.#trackedDevices[deviceData.serialNumber] = {
-            uuid: tempDevice.uuid,
-            rawDataUuid: deviceData.nest_google_uuid,
-            source: undefined,
-          };
-        }
-
-        if (
-          (deviceData.device_type === NestAccfactory.DeviceType.CAMERA ||
-            deviceData.device_type === NestAccfactory.DeviceType.DOORBELL ||
-            deviceData.device_type === NestAccfactory.DeviceType.FLOODLIGHT) &&
-          (typeof NestCamera === 'function' || typeof NestDoorbell === 'function' || typeof NestFloodlight === 'function')
-        ) {
-          let accessoryName = 'Nest ' + deviceData.model.replace(/\s*(?:\([^()]*\))/gi, '');
-          let tempDevice = undefined;
-          if (deviceData.device_type === NestAccfactory.DeviceType.CAMERA) {
-            // Nest Camera(s) - Categories.IP_CAMERA = 17
-            tempDevice = new NestCamera(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
-            tempDevice.add(accessoryName, 17, true);
-          }
-          if (deviceData.device_type === NestAccfactory.DeviceType.DOORBELL) {
-            // Nest Doorbell(s) - Categories.VIDEO_DOORBELL = 18
-            tempDevice = new NestDoorbell(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
-            tempDevice.add(accessoryName, 18, true);
-          }
-          if (deviceData.device_type === NestAccfactory.DeviceType.FLOODLIGHT) {
-            // Nest Camera(s) with Floodlight - Categories.IP_CAMERA = 17
-            tempDevice = new NestFloodlight(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
-            tempDevice.add(accessoryName, 17, true);
-          }
+        let deviceClass = this.#deviceModules.get(deviceData.device_type);
+        if (deviceClass !== undefined) {
+          // We have found a device class for this device type, so we can create the device
+          let accessoryName =
+            (deviceData.manufacturer?.trim() || 'Nest') +
+            ' ' +
+            deviceClass.TYPE.replace(/([a-z])([A-Z])/g, '$1 $2')
+              .replace(/[^a-zA-Z0-9 ]+/g, ' ')
+              .toLowerCase()
+              .replace(/\b\w/g, (character) => character.toUpperCase());
+          let tempDevice = new deviceClass(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
+          tempDevice.add(accessoryName, getDeviceHKCategory(deviceClass.TYPE), true);
 
           // Track this device once created
           this.#trackedDevices[deviceData.serialNumber] = {
@@ -1085,254 +844,241 @@ export default class NestAccfactory {
             rawDataUuid: deviceData.nest_google_uuid,
             source: undefined,
             timers: {},
+            exclude: false,
           };
 
-          // Setup polling loop for camera/doorbell zone data
-          // This is only required for REST API data sources as these details are present in Protobuf API
-          this.#trackedDevices[deviceData.serialNumber].timers.zones = setInterval(async () => {
-            let nest_google_uuid = this.#trackedDevices?.[deviceData?.serialNumber]?.rawDataUuid;
-            if (
-              this.#rawData?.[nest_google_uuid]?.value !== undefined &&
-              this.#trackedDevices?.[deviceData?.serialNumber]?.source === NestAccfactory.DataSource.REST
-            ) {
-              await fetchWrapper(
-                'get',
-                this.#rawData[nest_google_uuid].value.nexus_api_http_server_url + '/cuepoint_category/' + nest_google_uuid.split('.')[1],
-                {
-                  headers: {
-                    referer: 'https://' + this.#connections[this.#rawData[nest_google_uuid].connection].referer,
-                    'User-Agent': USERAGENT,
-                    [this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.key]:
-                      this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.value +
-                      this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.token,
-                  },
-                  timeout: CAMERAZONEPOLLING,
-                },
-              )
-                .then((response) => response.json())
-                .then((data) => {
-                  let zones = [];
-                  data.forEach((zone) => {
-                    if (zone.type.toUpperCase() === 'ACTIVITY' || zone.type.toUpperCase() === 'REGION') {
-                      zones.push({
-                        id: zone.id === 0 ? 1 : zone.id,
-                        name: makeHomeKitName(zone.label),
-                        hidden: zone.hidden === true,
-                        uri: zone.nexusapi_image_uri,
-                      });
-                    }
-                  });
+          // Optional things for each device type
+          if (
+            deviceClass.TYPE === DeviceType.CAMERA ||
+            deviceClass.TYPE === DeviceType.DOORBELL ||
+            deviceClass.TYPE === DeviceType.FLOODLIGHT
+          ) {
+            // Setup polling loop for camera/doorbell zone data
+            // This is only required for Nest API data sources as these details are present in Protobuf API
+            clearInterval(this.#trackedDevices?.[deviceData.serialNumber]?.timers?.zones);
+            this.#trackedDevices[deviceData.serialNumber].timers.zones = setInterval(async () => {
+              let nest_google_uuid = this.#trackedDevices?.[deviceData?.serialNumber]?.rawDataUuid;
+              if (
+                this.#rawData?.[nest_google_uuid]?.value !== undefined &&
+                this.#trackedDevices?.[deviceData?.serialNumber]?.source === DATASOURCE.NestAPI
+              ) {
+                try {
+                  let response = await fetchWrapper(
+                    'get',
+                    this.#rawData[nest_google_uuid].value.nexus_api_http_server_url +
+                      '/cuepoint_category/' +
+                      nest_google_uuid.split('.')[1],
+                    {
+                      headers: {
+                        referer: 'https://' + this.#connections[this.#rawData[nest_google_uuid].connection].referer,
+                        'User-Agent': USERAGENT,
+                        [this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.key]:
+                          this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.value +
+                          this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.token,
+                      },
+                      timeout: CAMERAZONEPOLLING,
+                    },
+                  );
+                  let data = await response.json();
+
+                  // Transform activity zones if present
+                  let zones =
+                    Array.isArray(data) === true
+                      ? data
+                        .filter((zone) => zone.type.toUpperCase() === 'ACTIVITY' || zone.type.toUpperCase() === 'REGION')
+                        .map((zone) => ({
+                          id: zone.id === 0 ? 1 : zone.id,
+                          name: makeHomeKitName(zone.label),
+                          hidden: zone.hidden === true,
+                          uri: zone.nexusapi_image_uri,
+                        }))
+                      : [];
 
                   // Update internal structure with new zone details.
-                  // We do a test to see if its still present not interval loop not finished or device removed
+                  // We do a test to see if it's still present, not interval loop not finished or device removed
                   if (this.#rawData?.[nest_google_uuid]?.value !== undefined) {
                     this.#rawData[nest_google_uuid].value.activity_zones = zones;
 
                     // Send updated data onto HomeKit device for it to process
-                    if (this.#eventEmitter !== undefined && this.#trackedDevices?.[deviceData?.serialNumber]?.uuid !== undefined) {
-                      this.#eventEmitter.emit(this.#trackedDevices[deviceData.serialNumber].uuid, HomeKitDevice.UPDATE, {
+                    this.#trackedDevices?.[deviceData?.serialNumber]?.uuid &&
+                      this.#eventEmitter?.emit?.(this.#trackedDevices[deviceData.serialNumber].uuid, HomeKitDevice.UPDATE, {
                         activity_zones: zones,
                       });
-                    }
                   }
-                })
-                .catch((error) => {
-                  // Log debug message if wasn't a timeout
-                  if (
-                    error?.cause !== undefined &&
-                    JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false &&
-                    this?.log?.debug
-                  ) {
-                    this.log.debug(
-                      'REST API had error retrieving camera/doorbell activity zones for "%s". Error was "%s"',
+                } catch (error) {
+                  // Log debug message if it wasn't a timeout
+                  if (error?.cause !== undefined && String(error.cause).toUpperCase().includes('TIMEOUT') === false) {
+                    this?.log?.debug?.(
+                      'Nest API had error retrieving camera/doorbell activity zones for "%s". Error was "%s"',
                       deviceData.description,
                       error?.code,
                     );
                   }
-                });
-            }
-          }, CAMERAZONEPOLLING);
+                }
+              }
+            }, CAMERAZONEPOLLING);
 
-          // Setup polling loop for camera/doorbell alert data
-          this.#trackedDevices[deviceData.serialNumber].timers.alerts = setInterval(async () => {
-            let alerts = []; // No alerts to processed yet
-            let nest_google_uuid = this.#trackedDevices?.[deviceData?.serialNumber]?.rawDataUuid;
-            if (
-              this.#rawData?.[nest_google_uuid]?.value !== undefined &&
-              this.#trackedDevices?.[deviceData?.serialNumber]?.source === NestAccfactory.DataSource.PROTOBUF
-            ) {
-              let commandResponse = await this.#protobufCommand(this.#rawData[nest_google_uuid].connection, 'ResourceApi', 'SendCommand', {
-                resourceRequest: {
-                  resourceId: nest_google_uuid,
-                  requestId: crypto.randomUUID(),
-                },
-                resourceCommands: [
+            // Setup polling loop for camera/doorbell alert data, clearing any existing polling loop
+            clearInterval(this.#trackedDevices?.[deviceData.serialNumber]?.timers?.alerts);
+            this.#trackedDevices[deviceData.serialNumber].timers.alerts = setInterval(async () => {
+              let alerts = []; // No alerts to processed yet
+              let nest_google_uuid = this.#trackedDevices?.[deviceData?.serialNumber]?.rawDataUuid;
+              if (
+                this.#rawData?.[nest_google_uuid]?.value !== undefined &&
+                this.#trackedDevices?.[deviceData?.serialNumber]?.source === DATASOURCE.ProtobufAPI
+              ) {
+                let commandResponse = await this.#protobufCommand(
+                  this.#rawData[nest_google_uuid].connection,
+                  'ResourceApi',
+                  'SendCommand',
                   {
-                    traitLabel: 'camera_observation_history',
-                    command: {
-                      type_url: 'type.nestlabs.com/nest.trait.history.CameraObservationHistoryTrait.CameraObservationHistoryRequest',
-                      value: {
-                        // We want camera history from now for upto 30secs from now
-                        queryStartTime: { seconds: Math.floor(Date.now() / 1000), nanos: (Math.round(Date.now()) % 1000) * 1e6 },
-                        queryEndTime: {
-                          seconds: Math.floor((Date.now() + 30000) / 1000),
-                          nanos: (Math.round(Date.now() + 30000) % 1000) * 1e6,
+                    resourceRequest: {
+                      resourceId: nest_google_uuid,
+                      requestId: crypto.randomUUID(),
+                    },
+                    resourceCommands: [
+                      {
+                        traitLabel: 'camera_observation_history',
+                        command: {
+                          type_url: 'type.nestlabs.com/nest.trait.history.CameraObservationHistoryTrait.CameraObservationHistoryRequest',
+                          value: {
+                            // We want camera history from now for upto 30secs from now
+                            queryStartTime: { seconds: Math.floor(Date.now() / 1000), nanos: (Math.round(Date.now()) % 1000) * 1e6 },
+                            queryEndTime: {
+                              seconds: Math.floor((Date.now() + 30000) / 1000),
+                              nanos: (Math.round(Date.now() + 30000) % 1000) * 1e6,
+                            },
+                          },
                         },
                       },
-                    },
+                    ],
                   },
-                ],
-              });
-
-              if (
-                typeof commandResponse?.sendCommandResponse?.[0]?.traitOperations?.[0]?.event?.event?.cameraEventWindow?.cameraEvent ===
-                'object'
-              ) {
-                commandResponse.sendCommandResponse[0].traitOperations[0].event.event.cameraEventWindow.cameraEvent.forEach((event) => {
-                  alerts.push({
-                    playback_time: parseInt(event.startTime.seconds) * 1000 + parseInt(event.startTime.nanos) / 1000000,
-                    start_time: parseInt(event.startTime.seconds) * 1000 + parseInt(event.startTime.nanos) / 1000000,
-                    end_time: parseInt(event.endTime.seconds) * 1000 + parseInt(event.endTime.nanos) / 1000000,
-                    id: event.eventId,
-                    zone_ids:
-                      typeof event.activityZone === 'object'
-                        ? event.activityZone.map((zone) => (zone?.zoneIndex !== undefined ? zone.zoneIndex : zone.internalIndex))
-                        : [],
-                    types: event.eventType
-                      .map((event) => (event.startsWith('EVENT_') === true ? event.split('EVENT_')[1].toLowerCase() : ''))
-                      .filter((event) => event),
-                  });
-
-                  // Fix up event types to match REST API
-                  // 'EVENT_UNFAMILIAR_FACE' = 'unfamiliar-face'
-                  // 'EVENT_PERSON_TALKING' = 'personHeard'
-                  // 'EVENT_DOG_BARKING' = 'dogBarking'
-                  // <---- TODO (as the ones we use match from Protobuf)
-                });
+                );
 
-                // Sort alerts to be most recent first
-                alerts = alerts.sort((a, b) => {
-                  if (a.start_time > b.start_time) {
-                    return -1;
-                  }
-                });
+                if (
+                  Array.isArray(
+                    commandResponse?.sendCommandResponse?.[0]?.traitOperations?.[0]?.event?.event?.cameraEventWindow?.cameraEvent,
+                  ) === true
+                ) {
+                  alerts = commandResponse.sendCommandResponse[0].traitOperations[0].event.event.cameraEventWindow.cameraEvent
+                    .map((event) => ({
+                      playback_time: parseInt(event.startTime.seconds) * 1000 + parseInt(event.startTime.nanos) / 1000000,
+                      start_time: parseInt(event.startTime.seconds) * 1000 + parseInt(event.startTime.nanos) / 1000000,
+                      end_time: parseInt(event.endTime.seconds) * 1000 + parseInt(event.endTime.nanos) / 1000000,
+                      id: event.eventId,
+                      zone_ids:
+                        typeof event.activityZone === 'object'
+                          ? event.activityZone.map((zone) => (zone?.zoneIndex !== undefined ? zone.zoneIndex : zone.internalIndex))
+                          : [],
+                      types: event.eventType
+                        .map((event) => {
+                          if (event === 'EVENT_UNFAMILIAR_FACE') {
+                            return 'unfamiliar-face';
+                          }
+                          if (event === 'EVENT_PERSON_TALKING') {
+                            return 'personHeard';
+                          }
+                          if (event === 'EVENT_DOG_BARKING') {
+                            return 'dogBarking';
+                          }
+                          return event.startsWith('EVENT_') ? event.split('EVENT_')[1].toLowerCase() : '';
+                        })
+                        .filter((event) => event),
+                    }))
+                    .sort((a, b) => b.start_time - a.start_time);
+                }
               }
-            }
 
-            if (
-              this.#rawData?.[nest_google_uuid]?.value !== undefined &&
-              this.#trackedDevices?.[deviceData?.serialNumber]?.source === NestAccfactory.DataSource.REST
-            ) {
-              await fetchWrapper(
-                'get',
-                this.#rawData[nest_google_uuid].value.nexus_api_http_server_url +
-                  '/cuepoint/' +
-                  nest_google_uuid.split('.')[1] +
-                  '/2?start_time=' +
-                  Math.floor(Date.now() / 1000 - 30),
-                {
-                  headers: {
-                    referer: 'https://' + this.#connections[this.#rawData[nest_google_uuid].connection].referer,
-                    'User-Agent': USERAGENT,
-                    [this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.key]:
-                      this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.value +
-                      this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.token,
-                  },
-                  timeout: CAMERAALERTPOLLING,
-                  retry: 3,
-                },
-              )
-                .then((response) => response.json())
-                .then((data) => {
-                  data.forEach((alert) => {
-                    // Fix up alert zone IDs. If there is an ID of 0, we'll transform to 1. ie: main zone
-                    // If there are NO zone IDs, we'll put a 1 in there ie: main zone
-                    alert.zone_ids = alert.zone_ids.map((id) => (id !== 0 ? id : 1));
-                    if (alert.zone_ids.length === 0) {
-                      alert.zone_ids.push(1);
-                    }
-                    alerts.push({
-                      playback_time: alert.playback_time,
-                      start_time: alert.start_time,
-                      end_time: alert.end_time,
-                      id: alert.id,
-                      zone_ids: alert.zone_ids,
-                      types: alert.types,
-                    });
-                  });
+              if (
+                this.#rawData?.[nest_google_uuid]?.value !== undefined &&
+                this.#trackedDevices?.[deviceData?.serialNumber]?.source === DATASOURCE.NestAPI
+              ) {
+                try {
+                  let response = await fetchWrapper(
+                    'get',
+                    this.#rawData[nest_google_uuid].value.nexus_api_http_server_url +
+                      '/cuepoint/' +
+                      nest_google_uuid.split('.')[1] +
+                      '/2?start_time=' +
+                      Math.floor(Date.now() / 1000 - 30),
+                    {
+                      headers: {
+                        referer: 'https://' + this.#connections[this.#rawData[nest_google_uuid].connection].referer,
+                        'User-Agent': USERAGENT,
+                        [this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.key]:
+                          this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.value +
+                          this.#connections[this.#rawData[nest_google_uuid].connection].cameraAPI.token,
+                      },
+                      timeout: CAMERAALERTPOLLING,
+                      retry: 3,
+                    },
+                  );
 
-                  // Sort alerts to be most recent first
-                  alerts = alerts.sort((a, b) => {
-                    if (a.start_time > b.start_time) {
-                      return -1;
-                    }
-                  });
-                })
-                .catch((error) => {
-                  // Log debug message if wasn't a timeout
-                  if (
-                    error?.cause !== undefined &&
-                    JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false &&
-                    this?.log?.debug
-                  ) {
-                    this.log.debug(
-                      'REST API had error retrieving camera/doorbell activity notifications for "%s". Error was "%s"',
+                  let data = await response.json();
+
+                  alerts =
+                    Array.isArray(data) === true
+                      ? data
+                        .map((alert) => {
+                          alert.zone_ids = alert.zone_ids.map((id) => (id !== 0 ? id : 1));
+                          if (alert.zone_ids.length === 0) {
+                            alert.zone_ids.push(1);
+                          }
+                          return {
+                            playback_time: alert.playback_time,
+                            start_time: alert.start_time,
+                            end_time: alert.end_time,
+                            id: alert.id,
+                            zone_ids: alert.zone_ids,
+                            types: alert.types,
+                          };
+                        })
+                        .sort((a, b) => b.start_time - a.start_time)
+                      : [];
+                } catch (error) {
+                  if (error?.cause !== undefined && String(error.cause).toUpperCase().includes('TIMEOUT') === false) {
+                    this?.log?.debug?.(
+                      'Nest API had error retrieving camera/doorbell activity notifications for "%s". Error was "%s"',
                       deviceData.description,
                       error?.code,
                     );
                   }
-                });
-            }
-
-            // Update internal structure with new alerts.
-            // We do a test to see if its still present not interval loop not finished or device removed
-            if (this.#rawData?.[nest_google_uuid]?.value !== undefined) {
-              this.#rawData[nest_google_uuid].value.alerts = alerts;
-
-              // Send updated alerts onto HomeKit device for it to process
-              if (this.#eventEmitter !== undefined && this.#trackedDevices?.[deviceData?.serialNumber]?.uuid !== undefined) {
-                this.#eventEmitter.emit(this.#trackedDevices[deviceData.serialNumber].uuid, HomeKitDevice.UPDATE, {
-                  alerts: alerts,
-                });
+                }
               }
-            }
-          }, CAMERAALERTPOLLING);
-        }
-
-        if (deviceData.device_type === NestAccfactory.DeviceType.WEATHER && typeof NestWeather === 'function') {
-          // Nest 'Virtual' weather station - Categories.SENSOR = 10
-          let tempDevice = new NestWeather(this.cachedAccessories, this.api, this.log, this.#eventEmitter, deviceData);
-          tempDevice.add('Nest Weather', 10, true);
 
-          // Track this device once created
-          this.#trackedDevices[deviceData.serialNumber] = {
-            uuid: tempDevice.uuid,
-            rawDataUuid: deviceData.nest_google_uuid,
-            source: undefined,
-            timers: {},
-          };
+              // Update internal structure with new alerts.
+              // We do a test to see if its still present not interval loop not finished or device removed
+              if (this.#rawData?.[nest_google_uuid]?.value !== undefined) {
+                this.#rawData[nest_google_uuid].value.alerts = alerts;
 
-          // Setup polling loop for weather data
-          this.#trackedDevices[deviceData.serialNumber].timers.weather = setInterval(async () => {
-            let nest_google_uuid = this.#trackedDevices?.[deviceData?.serialNumber]?.rawDataUuid;
-            if (this.#rawData?.[nest_google_uuid] !== undefined) {
-              this.#rawData[nest_google_uuid].value.weather = await this.#getWeatherData(
-                this.#rawData[nest_google_uuid].connection,
-                nest_google_uuid,
-                this.#rawData[nest_google_uuid].value.weather.latitude,
-                this.#rawData[nest_google_uuid].value.weather.longitude,
-              );
+                // Send updated alerts onto HomeKit device for it to process
+                this.#trackedDevices?.[deviceData?.serialNumber]?.uuid &&
+                  this.#eventEmitter?.emit?.(this.#trackedDevices[deviceData.serialNumber].uuid, HomeKitDevice.UPDATE, { alerts: alerts });
+              }
+            }, CAMERAALERTPOLLING);
+          }
 
-              // Send updated weather data onto HomeKit device for it to process
-              if (this.#eventEmitter !== undefined && this.#trackedDevices?.[deviceData?.serialNumber]?.uuid !== undefined) {
-                this.#eventEmitter.emit(
-                  this.#trackedDevices[deviceData.serialNumber].uuid,
-                  HomeKitDevice.UPDATE,
-                  this.#processData(nest_google_uuid)[deviceData.serialNumber],
+          if (deviceClass.TYPE === DeviceType.WEATHER) {
+            // Setup polling loop for weather data, clearing any existing polling loop
+            clearInterval(this.#trackedDevices?.[deviceData.serialNumber]?.timers?.weather);
+            this.#trackedDevices[deviceData.serialNumber].timers.weather = setInterval(async () => {
+              if (this.#rawData?.[this.#trackedDevices?.[deviceData.serialNumber]?.rawDataUuid] !== undefined) {
+                this.#rawData[this.#trackedDevices[deviceData.serialNumber].rawDataUuid].value.weather = await this.#getWeather(
+                  this.#rawData[this.#trackedDevices[deviceData.serialNumber].rawDataUuid].connection,
+                  this.#trackedDevices[deviceData.serialNumber].rawDataUuid,
+                  this.#rawData[this.#trackedDevices[deviceData.serialNumber].rawDataUuid].value.weather.latitude,
+                  this.#rawData[this.#trackedDevices[deviceData.serialNumber].rawDataUuid].value.weather.longitude,
                 );
+
+                this.#trackedDevices?.[deviceData.serialNumber]?.uuid &&
+                  this.#eventEmitter?.emit?.(
+                    this.#trackedDevices[deviceData.serialNumber].uuid,
+                    HomeKitDevice.UPDATE,
+                    this.#processData(this.#trackedDevices[deviceData.serialNumber].rawDataUuid)?.[deviceData.serialNumber],
+                  );
               }
-            }
-          }, WEATHERPOLLING);
+            }, WEATHERPOLLING);
+          }
         }
       }
 
@@ -1343,21 +1089,19 @@ export default class NestAccfactory {
           this.#rawData[deviceData.nest_google_uuid].source !== this.#trackedDevices[deviceData.serialNumber].source
         ) {
           // Data source for this device has been updated
-          this?.log?.debug &&
-            this.log.debug(
-              'Using %s API as data source for "%s" from connection uuid "%s"',
-              this.#rawData[deviceData.nest_google_uuid]?.source,
-              deviceData.description,
-              this.#rawData[deviceData.nest_google_uuid].connection,
-            );
+          this?.log?.debug?.(
+            'Using %s API as data source for "%s" from connection uuid "%s"',
+            this.#rawData[deviceData.nest_google_uuid]?.source,
+            deviceData.description,
+            this.#rawData[deviceData.nest_google_uuid].connection,
+          );
 
           this.#trackedDevices[deviceData.serialNumber].source = this.#rawData[deviceData.nest_google_uuid].source;
           this.#trackedDevices[deviceData.serialNumber].rawDataUuid = deviceData.nest_google_uuid;
         }
 
-        if (this.#eventEmitter !== undefined) {
-          this.#eventEmitter.emit(this.#trackedDevices[deviceData.serialNumber].uuid, HomeKitDevice.UPDATE, deviceData);
-        }
+        this.#trackedDevices?.[deviceData?.serialNumber]?.uuid &&
+          this.#eventEmitter?.emit?.(this.#trackedDevices[deviceData.serialNumber].uuid, HomeKitDevice.UPDATE, deviceData);
       }
     });
   }
@@ -1368,37 +1112,69 @@ export default class NestAccfactory {
     }
     let devices = {};
 
-    // Get the device(s) location from stucture
-    // We'll test in both REST and Protobuf API data
+    // Get the device(s) location from structure
+    // We'll test in both Nest and Protobuf API data
     const get_location_name = (structure_id, where_id) => {
       let location = '';
 
-      // Check REST data
-      if (typeof this.#rawData?.['where.' + structure_id]?.value === 'object') {
-        this.#rawData['where.' + structure_id].value.wheres.forEach((value) => {
-          if (where_id === value.where_id) {
-            location = value.name;
+      if (typeof structure_id === 'string' && typeof where_id === 'string') {
+        // Check Nest data
+        if (typeof this.#rawData?.['where.' + structure_id]?.value === 'object') {
+          this.#rawData['where.' + structure_id].value.wheres.forEach((value) => {
+            if (where_id === value.where_id) {
+              location = value.name;
+            }
+          });
+        }
+
+        // Check Protobuf data (combined predefined and custom)
+        let protobufWheres = [
+          ...Object.values(this.#rawData?.[structure_id]?.value?.located_annotations?.predefinedWheres || {}),
+          ...Object.values(this.#rawData?.[structure_id]?.value?.located_annotations?.customWheres || {}),
+        ];
+
+        protobufWheres.forEach((value) => {
+          if (value?.whereId?.resourceId === where_id) {
+            location = value.label?.literal;
           }
         });
       }
+      return location;
+    };
 
-      // Check Protobuf data
-      if (typeof this.#rawData[structure_id]?.value?.located_annotations?.predefinedWheres === 'object') {
-        Object.values(this.#rawData[structure_id].value.located_annotations.predefinedWheres).forEach((value) => {
-          if (value.whereId.resourceId === where_id) {
-            location = value.label.literal;
+    // Process software version strings and return as x.x.x
+    // handles things like:
+    // 1.0a17 -> 1.0.17
+    // 3.6rc8 -> 3.6.8
+    // rquartz-user 1 OPENMASTER 507800056 test-keys stable-channel stable-channel -> 507800056
+    // nq-user 1.73 OPENMASTER 422270 release-keys stable-channel stable-channel -> 422270
+    const process_software_version = (versionString) => {
+      let version = '0.0.0';
+      if (typeof versionString === 'string') {
+        let normalised = versionString.replace(/[-_]/g, '.');
+        let tokens = normalised.split(/\s+/);
+        let candidate = tokens[3] || normalised;
+        let match = candidate.match(/\d+(?:\.\d+)*[a-zA-Z]*\d*/) || normalised.match(/\d+(?:\.\d+)*[a-zA-Z]*\d*/);
+
+        if (Array.isArray(match)) {
+          let raw = match[0];
+          if (raw.includes('.') === false) {
+            return raw; // Return single-number version like "422270" as-is
           }
-        });
-      }
-      if (typeof this.#rawData[structure_id]?.value?.located_annotations?.customWheres === 'object') {
-        Object.values(this.#rawData[structure_id].value.located_annotations.customWheres).forEach((value) => {
-          if (value.whereId.resourceId === where_id) {
-            location = value.label.literal;
+
+          let parts = raw.split('.').flatMap((part) => {
+            let [, n1, , n2] = part.match(/^(\d+)([a-zA-Z]+)?(\d+)?$/) || [];
+            return [n1, n2].filter(Boolean).map(Number);
+          });
+
+          while (parts.length < 3) {
+            parts.push(0);
           }
-        });
+          version = parts.slice(0, 3).join('.');
+        }
       }
 
-      return location;
+      return version;
     };
 
     // Process common data for all devices
@@ -1406,38 +1182,43 @@ export default class NestAccfactory {
       let processed = {};
       try {
         // Fix up data we need to
+        let deviceOptions = this.config?.devices?.find(
+          (device) => device?.serialNumber?.toUpperCase?.() === data?.serialNumber?.toUpperCase?.(),
+        );
         data.nest_google_uuid = object_key;
         data.serialNumber = data.serialNumber.toUpperCase(); // ensure serial numbers are in upper case
-        data.excluded = this.config?.devices?.[data?.serialNumber]?.exclude === true; // Mark device as excluded or not
-        data.manufacturer = typeof data?.manufacturer === 'string' ? data.manufacturer : 'Nest';
-        data.softwareVersion =
-          typeof data?.softwareVersion === 'string' ? data.softwareVersion.replace(/([a-zA-Z]+)/g, '.').replace(/-/g, '.') : '0.0.0';
+        data.excluded = this?.config?.options?.exclude === true ? deviceOptions?.exclude !== false : deviceOptions?.exclude === true;
+        data.manufacturer = typeof data?.manufacturer === 'string' && data.manufacturer !== '' ? data.manufacturer : 'Nest';
+        data.softwareVersion = process_software_version(data.softwareVersion);
         let description = typeof data?.description === 'string' ? data.description : '';
         let location = typeof data?.location === 'string' ? data.location : '';
-        if (description === '') {
+        if (description === '' && location !== '') {
           description = location;
           location = '';
         }
+        if (description === '' && location === '') {
+          description = 'unknown description';
+        }
         data.description = makeHomeKitName(location === '' ? description : description + ' - ' + location);
         delete data.location;
 
         // Insert HomeKit pairing code for when using HAP-NodeJS library rather than Homebridge
         // Validate the pairing code is in the format of "xxx-xx-xxx" or "xxxx-xxxx"
         if (
-          new RegExp(/^([0-9]{3}-[0-9]{2}-[0-9]{3})$/).test(this.config?.options?.hkPairingCode) === true ||
-          new RegExp(/^([0-9]{4}-[0-9]{4})$/).test(this.config?.options?.hkPairingCode) === true
+          typeof this.config?.options?.hkPairingCode === 'string' &&
+          (HomeKitDevice.HK_PIN_3_2_3.test(this.config.options.hkPairingCode) ||
+            HomeKitDevice.HK_PIN_4_4.test(this.config.options.hkPairingCode))
         ) {
           data.hkPairingCode = this.config.options.hkPairingCode;
-        }
-        if (
-          new RegExp(/^([0-9]{3}-[0-9]{2}-[0-9]{3})$/).test(this.config?.devices?.[data.serialNumber]?.hkPairingCode) === true ||
-          new RegExp(/^([0-9]{4}-[0-9]{4})$/).test(this.config?.devices?.[data.serialNumber]?.hkPairingCode) === true
+        } else if (
+          typeof deviceOptions?.hkPairingCode === 'string' &&
+          (HomeKitDevice.HK_PIN_3_2_3.test(deviceOptions.hkPairingCode) || HomeKitDevice.HK_PIN_4_4.test(deviceOptions.hkPairingCode))
         ) {
-          data.hkPairingCode = this.config.devices[data.serialNumber].hkPairingCode;
+          data.hkPairingCode = deviceOptions.hkPairingCode;
         }
 
         // If we have a hkPairingCode defined, we need to generate a hkUsername also
-        if (data.hkPairingCode !== undefined) {
+        if (data?.hkPairingCode !== undefined) {
           // Use a Nest Labs prefix for first 6 digits, followed by a CRC24 based off serial number for last 6 digits.
           data.hkUsername = ('18B430' + crc24(data.serialNumber.toUpperCase()))
             .toString('hex')
@@ -1459,14 +1240,19 @@ export default class NestAccfactory {
       let processed = {};
       try {
         // Fix up data we need to
+        data.device_type = DeviceType.THERMOSTAT; // Nest Thermostat
+
+        // If we have hot water control, it should be a 'UK/EU' model, so add that after the 'gen' tag in the model name
+        data.model = data.has_hot_water_control === true ? data.model.replace(/\bgen\)/, 'gen, EU)') : data.model;
+
         data = process_common_data(object_key, data);
-        data.device_type = NestAccfactory.DeviceType.THERMOSTAT; // Nest Thermostat
         data.target_temperature_high = adjustTemperature(data.target_temperature_high, 'C', 'C', true);
         data.target_temperature_low = adjustTemperature(data.target_temperature_low, 'C', 'C', true);
         data.target_temperature = adjustTemperature(data.target_temperature, 'C', 'C', true);
         data.backplate_temperature = adjustTemperature(data.backplate_temperature, 'C', 'C', true);
         data.current_temperature = adjustTemperature(data.current_temperature, 'C', 'C', true);
         data.battery_level = scaleValue(data.battery_level, 3.6, 3.9, 0, 100);
+
         processed = data;
         // eslint-disable-next-line no-unused-vars
       } catch (error) {
@@ -1476,6 +1262,10 @@ export default class NestAccfactory {
     };
 
     const PROTOBUF_THERMOSTAT_RESOURCES = [
+      'nest.resource.NestAmber1DisplayResource',
+      'nest.resource.NestAmber2DisplayResource',
+      'nest.resource.NestLearningThermostat1Resource',
+      'nest.resource.NestLearningThermostat2Resource',
       'nest.resource.NestLearningThermostat3Resource',
       'nest.resource.NestAgateDisplayResource',
       'nest.resource.NestOnyxResource',
@@ -1493,50 +1283,55 @@ export default class NestAccfactory {
         let tempDevice = {};
         try {
           if (
-            value?.source === NestAccfactory.DataSource.PROTOBUF &&
-            this.config.options?.protobufAPI === true &&
+            value?.source === DATASOURCE.ProtobufAPI &&
+            this.config.options?.useGoogleAPI === true &&
             value.value?.configuration_done?.deviceReady === true
           ) {
             let RESTTypeData = {};
             RESTTypeData.serialNumber = value.value.device_identity.serialNumber;
-            RESTTypeData.softwareVersion =
-              value.value.device_identity.softwareVersion.split(/\s+/)?.[3] !== undefined
-                ? value.value.device_identity.softwareVersion.split(/\s+/)?.[3]
-                : value.value.device_identity.softwareVersion;
-            RESTTypeData.model = 'Thermostat';
-            if (value.value.device_info.typeName === 'nest.resource.NestLearningThermostat3Resource') {
+            RESTTypeData.softwareVersion = value.value.device_identity.softwareVersion;
+            RESTTypeData.model = 'Thermostat (unknown)';
+            if (value.value.device_info.typeName === 'nest.resource.NestLearningThermostat1Resource') {
+              RESTTypeData.model = 'Learning Thermostat (1st gen)';
+            }
+            if (value.value.device_info.typeName === 'nest.resource.NestLearningThermostat2Resource') {
+              RESTTypeData.model = 'Learning Thermostat (2nd gen)';
+            }
+            if (
+              value.value.device_info.typeName === 'nest.resource.NestLearningThermostat3Resource' ||
+              value.value.device_info.typeName === 'nest.resource.NestAmber2DisplayResource'
+            ) {
               RESTTypeData.model = 'Learning Thermostat (3rd gen)';
             }
             if (value.value.device_info.typeName === 'google.resource.GoogleBismuth1Resource') {
               RESTTypeData.model = 'Learning Thermostat (4th gen)';
             }
-            if (value.value.device_info.typeName === 'nest.resource.NestAgateDisplayResource') {
-              RESTTypeData.model = 'Thermostat E';
-            }
-            if (value.value.device_info.typeName === 'nest.resource.NestOnyxResource') {
+            if (
+              value.value.device_info.typeName === 'nest.resource.NestOnyxResource' ||
+              value.value.device_info.typeName === 'nest.resource.NestAgateDisplayResource'
+            ) {
               RESTTypeData.model = 'Thermostat E (1st gen)';
             }
             if (value.value.device_info.typeName === 'google.resource.GoogleZirconium1Resource') {
-              RESTTypeData.model = 'Thermostat (2020 Model)';
+              RESTTypeData.model = 'Thermostat (2020)';
             }
             RESTTypeData.current_humidity =
-              isNaN(value.value.current_humidity.humidityValue.humidity.value) === false
+              isNaN(value.value?.current_humidity?.humidityValue?.humidity?.value) === false
                 ? Number(value.value.current_humidity.humidityValue.humidity.value)
                 : 0.0;
-            RESTTypeData.temperature_scale = value.value.display_settings.temperatureScale === 'TEMPERATURE_SCALE_F' ? 'F' : 'C';
-            RESTTypeData.removed_from_base = value.value.display.thermostatState.includes('bpd') === true;
+            RESTTypeData.temperature_scale = value.value?.display_settings?.temperatureScale === 'TEMPERATURE_SCALE_F' ? 'F' : 'C';
+            RESTTypeData.removed_from_base =
+              Array.isArray(value.value?.display?.thermostatState) === true && value.value?.display.thermostatState.includes('bpd');
             RESTTypeData.backplate_temperature = parseFloat(value.value.backplate_temperature.temperatureValue.temperature.value);
             RESTTypeData.current_temperature = parseFloat(value.value.current_temperature.temperatureValue.temperature.value);
             RESTTypeData.battery_level = parseFloat(value.value.battery_voltage.batteryValue.batteryVoltage.value);
             RESTTypeData.online = value.value?.liveness?.status === 'LIVENESS_DEVICE_STATUS_ONLINE';
             RESTTypeData.leaf = value.value?.leaf?.active === true;
-            RESTTypeData.has_humidifier = value.value.hvac_equipment_capabilities.hasHumidifier === true;
-            RESTTypeData.has_dehumidifier = value.value.hvac_equipment_capabilities.hasDehumidifier === true;
+            RESTTypeData.has_humidifier = value.value?.hvac_equipment_capabilities?.hasHumidifier === true;
+            RESTTypeData.has_dehumidifier = value.value?.hvac_equipment_capabilities?.hasDehumidifier === true;
             RESTTypeData.has_fan =
-              typeof value.value.fan_control_capabilities.maxAvailableSpeed === 'string' &&
-              value.value.fan_control_capabilities.maxAvailableSpeed !== 'FAN_SPEED_SETTING_OFF'
-                ? true
-                : false;
+              typeof value.value?.fan_control_capabilities?.maxAvailableSpeed === 'string' &&
+              value.value.fan_control_capabilities.maxAvailableSpeed !== 'FAN_SPEED_SETTING_OFF';
             RESTTypeData.can_cool =
               value.value?.hvac_equipment_capabilities?.hasStage1Cool === true ||
               value.value?.hvac_equipment_capabilities?.hasStage2Cool === true ||
@@ -1641,7 +1436,9 @@ export default class NestAccfactory {
             }
 
             // Update fan status, on or off and max number of speeds supported
-            RESTTypeData.fan_state = parseInt(value.value.fan_control_settings.timerEnd?.seconds) > 0 ? true : false;
+            RESTTypeData.fan_state =
+              isNaN(value.value?.fan_control_settings?.timerEnd?.seconds) === false &&
+              Number(value.value.fan_control_settings.timerEnd.seconds) > 0;
             RESTTypeData.fan_timer_speed =
               value.value.fan_control_settings.timerSpeed.includes('FAN_SPEED_SETTING_STAGE') === true &&
               isNaN(value.value.fan_control_settings.timerSpeed.split('FAN_SPEED_SETTING_STAGE')[1]) === false
@@ -1662,31 +1459,23 @@ export default class NestAccfactory {
             RESTTypeData.has_air_filter = value.value.hvac_equipment_capabilities.hasAirFilter === true;
             RESTTypeData.filter_replacement_needed = value.value.filter_reminder.filterReplacementNeeded.value === true;
 
+            // Hotwater details
+            RESTTypeData.has_hot_water_control = value.value?.hvac_equipment_capabilities?.hasHotWaterControl === true;
+            RESTTypeData.hot_water_active = value.value?.hot_water?.boilerActive === true;
+            RESTTypeData.hot_water_boost_active =
+              isNaN(value.value?.hot_water_settings?.boostTimerEnd?.seconds) === false &&
+              Number(value.value.hot_water_settings.boostTimerEnd.seconds) > 0;
+
             // Process any temperature sensors associated with this thermostat
             RESTTypeData.active_rcs_sensor =
-              value.value.remote_comfort_sensing_settings?.activeRcsSelection?.activeRcsSensor !== undefined
+              value.value?.remote_comfort_sensing_settings?.activeRcsSelection?.activeRcsSensor !== undefined
                 ? value.value.remote_comfort_sensing_settings.activeRcsSelection.activeRcsSensor.resourceId
                 : '';
-            RESTTypeData.linked_rcs_sensors = [];
-            if (value.value?.remote_comfort_sensing_settings?.associatedRcsSensors !== undefined) {
-              value.value.remote_comfort_sensing_settings.associatedRcsSensors.forEach((sensor) => {
-                if (this.#rawData?.[sensor.deviceId.resourceId]?.value !== undefined) {
-                  this.#rawData[sensor.deviceId.resourceId].value.associated_thermostat = object_key; // Sensor is linked to this thermostat
-
-                  // Get sensor online/offline status
-                  // 'liveness' property doesn't appear in Protobuf data for temp sensors, so we'll add that object here
-                  this.#rawData[sensor.deviceId.resourceId].value.liveness = {};
-                  this.#rawData[sensor.deviceId.resourceId].value.liveness.status = 'LIVENESS_DEVICE_STATUS_UNSPECIFIED';
-                  if (value.value?.remote_comfort_sensing_state?.rcsSensorStatuses !== undefined) {
-                    Object.values(value.value.remote_comfort_sensing_state.rcsSensorStatuses).forEach((sensorStatus) => {
-                      if (
-                        sensorStatus?.sensorId?.resourceId === sensor.deviceId.resourceId &&
-                        sensorStatus?.dataRecency?.includes('OK') === true
-                      ) {
-                        this.#rawData[sensor.deviceId.resourceId].value.liveness.status = 'LIVENESS_DEVICE_STATUS_ONLINE';
-                      }
-                    });
-                  }
+            RESTTypeData.linked_rcs_sensors = [];
+            if (Array.isArray(value.value?.remote_comfort_sensing_settings?.associatedRcsSensors) === true) {
+              value.value.remote_comfort_sensing_settings.associatedRcsSensors.forEach((sensor) => {
+                if (typeof this.#rawData?.[sensor?.deviceId?.resourceId]?.value === 'object') {
+                  this.#rawData[sensor.deviceId.resourceId].value.associated_thermostat = object_key; // Sensor is linked to this thermostat
                 }
 
                 RESTTypeData.linked_rcs_sensors.push(sensor.deviceId.resourceId);
@@ -1694,7 +1483,7 @@ export default class NestAccfactory {
             }
 
             RESTTypeData.schedule_mode =
-              value.value?.target_temperature_settings?.targetTemperature?.setpointType !== undefined &&
+              typeof value.value?.target_temperature_settings?.targetTemperature?.setpointType === 'string' &&
               value.value.target_temperature_settings.targetTemperature.setpointType.split('SET_POINT_TYPE_')[1].toLowerCase() !== 'off'
                 ? value.value.target_temperature_settings.targetTemperature.setpointType.split('SET_POINT_TYPE_')[1].toLowerCase()
                 : '';
@@ -1705,7 +1494,7 @@ export default class NestAccfactory {
                 'SET_POINT_SCHEDULE_TYPE_' + RESTTypeData.schedule_mode.toUpperCase()
             ) {
               Object.values(value.value[RESTTypeData.schedule_mode + '_schedule_settings'].setpoints).forEach((schedule) => {
-                // Create REST API schedule entries
+                // Create Nest API schedule entries
                 const DAYSOFWEEK = ['MONDAY', 'TUESDAY', 'WEDNESDAY', 'THURSDAY', 'FRIDAY', 'SATURDAY', 'SUNDAY'];
                 let dayofWeekIndex = DAYSOFWEEK.indexOf(schedule.dayOfWeek.split('DAY_OF_WEEK_')[1]);
 
@@ -1716,7 +1505,7 @@ export default class NestAccfactory {
                 RESTTypeData.schedules[dayofWeekIndex][Object.entries(RESTTypeData.schedules[dayofWeekIndex]).length] = {
                   'temp-min': adjustTemperature(schedule.heatingTarget.value, 'C', 'C', true),
                   'temp-max': adjustTemperature(schedule.coolingTarget.value, 'C', 'C', true),
-                  time: isNaN(schedule.secondsInDay) === false ? Number(schedule.secondsInDay) : 0,
+                  time: isNaN(schedule?.secondsInDay) === false ? Number(schedule.secondsInDay) : 0,
                   type: RESTTypeData.schedule_mode.toUpperCase(),
                   entry_type: 'setpoint',
                 };
@@ -1726,26 +1515,22 @@ export default class NestAccfactory {
             tempDevice = process_thermostat_data(object_key, RESTTypeData);
           }
 
-          if (
-            value?.source === NestAccfactory.DataSource.REST &&
-            this.config.options?.restAPI === true &&
-            value.value?.where_id !== undefined
-          ) {
+          if (value?.source === DATASOURCE.NestAPI && this.config.options?.useNestAPI === true && value.value?.where_id !== undefined) {
             let RESTTypeData = {};
             RESTTypeData.serialNumber = value.value.serial_number;
             RESTTypeData.softwareVersion = value.value.current_version;
-            RESTTypeData.model = 'Thermostat';
+            RESTTypeData.model = 'Thermostat (unknown)';
             if (value.value.serial_number.substring(0, 2) === '15') {
               RESTTypeData.model = 'Thermostat E (1st gen)'; // Nest Thermostat E
             }
-            if (value.value.serial_number.substring(0, 2) === '09') {
-              RESTTypeData.model = 'Thermostat (3rd gen)'; // Nest Thermostat 3rd Gen
+            if (value.value.serial_number.substring(0, 2) === '09' || value.value.serial_number.substring(0, 2) === '10') {
+              RESTTypeData.model = 'Learning Thermostat (3rd gen)'; // Nest Thermostat 3rd gen
             }
             if (value.value.serial_number.substring(0, 2) === '02') {
-              RESTTypeData.model = 'Thermostat (2nd gen)'; // Nest Thermostat 2nd Gen
+              RESTTypeData.model = 'Learning Thermostat (2nd gen)'; // Nest Thermostat 2nd gen
             }
             if (value.value.serial_number.substring(0, 2) === '01') {
-              RESTTypeData.model = 'Thermostat (1st gen)'; // Nest Thermostat 1st Gen
+              RESTTypeData.model = 'Learning Thermostat (1st gen)'; // Nest Thermostat 1st gen
             }
             RESTTypeData.current_humidity = value.value.current_humidity;
             RESTTypeData.temperature_scale = value.value.temperature_scale;
@@ -1872,7 +1657,7 @@ export default class NestAccfactory {
             }
 
             // Update fan status, on or off
-            RESTTypeData.fan_state = value.value.fan_timer_timeout > 0 ? true : false;
+            RESTTypeData.fan_state = isNaN(value.value.fan_timer_timeout) === false && Number(value.value.fan_timer_timeout) > 0;
             RESTTypeData.fan_timer_speed =
               value.value.fan_timer_speed.includes('stage') === true && isNaN(value.value.fan_timer_speed.split('stage')[1]) === false
                 ? Number(value.value.fan_timer_speed.split('stage')[1])
@@ -1891,6 +1676,12 @@ export default class NestAccfactory {
             RESTTypeData.has_air_filter = value.value.has_air_filter === true;
             RESTTypeData.filter_replacement_needed = value.value.filter_replacement_needed === true;
 
+            // Hotwater details
+            RESTTypeData.has_hot_water_control = value.value.has_hot_water_control === true;
+            RESTTypeData.hot_water_active = value.value?.hot_water_active === true;
+            RESTTypeData.hot_water_boost_active =
+              isNaN(value.value?.hot_water_boost_time_to_end) === false && Number(value.value.hot_water_boost_time_to_end) > 0;
+
             // Process any temperature sensors associated with this thermostat
             RESTTypeData.active_rcs_sensor = '';
             RESTTypeData.linked_rcs_sensors = [];
@@ -1936,30 +1727,31 @@ export default class NestAccfactory {
           }
           // eslint-disable-next-line no-unused-vars
         } catch (error) {
-          this?.log?.debug && this.log.debug('Error processing data for thermostat(s)');
+          this?.log?.debug?.('Error processing data for thermostat(s)');
         }
 
         if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serialNumber] === 'undefined') {
+          let deviceOptions = this.config?.devices?.find(
+            (device) => device?.serialNumber?.toUpperCase?.() === tempDevice?.serialNumber?.toUpperCase?.(),
+          );
           // Insert any extra options we've read in from configuration file for this device
-          tempDevice.eveHistory =
-            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serialNumber]?.eveHistory === true;
-          tempDevice.humiditySensor = this.config?.devices?.[tempDevice.serialNumber]?.humiditySensor === true;
+          tempDevice.eveHistory = this.config.options.eveHistory === true || deviceOptions?.eveHistory === true;
+          tempDevice.humiditySensor = deviceOptions?.humiditySensor === true;
           tempDevice.externalCool =
-            typeof this.config?.devices?.[tempDevice.serialNumber]?.externalCool === 'string'
-              ? this.config.devices[tempDevice.serialNumber].externalCool
-              : undefined; // Config option for external cooling source
+            typeof deviceOptions?.externalCool === 'string' && deviceOptions.externalCool !== '' ? deviceOptions.externalCool : undefined; // Config option for external cooling source
           tempDevice.externalHeat =
-            typeof this.config?.devices?.[tempDevice.serialNumber]?.externalHeat === 'string'
-              ? this.config.devices[tempDevice.serialNumber].externalHeat
-              : undefined; // Config option for external heating source
+            typeof deviceOptions?.externalHeat === 'string' && deviceOptions.externalHeat !== '' ? deviceOptions.externalHeat : undefined; // Config option for external heating source
           tempDevice.externalFan =
-            typeof this.config?.devices?.[tempDevice.serialNumber]?.externalFan === 'string'
-              ? this.config.devices[tempDevice.serialNumber].externalFan
-              : undefined; // Config option for external fan source
+            typeof deviceOptions?.externalFan === 'string' && deviceOptions.externalFan !== '' ? deviceOptions.externalFan : undefined; // Config option for external fan source
           tempDevice.externalDehumidifier =
-            typeof this.config?.devices?.[tempDevice.serialNumber]?.externalDehumidifier === 'string'
-              ? this.config.devices[tempDevice.serialNumber].externalDehumidifier
+            typeof deviceOptions?.externalDehumidifier === 'string' && deviceOptions.externalDehumidifier !== ''
+              ? deviceOptions.externalDehumidifier
               : undefined; // Config option for external dehumidifier source
+          tempDevice.hotWaterBoostTime = parseDurationToSeconds(deviceOptions?.hotWaterBoostTime, {
+            defaultValue: 30 * 60, // 30mins
+            min: 60, // 1min
+            max: 7200, // 2hrs
+          });
           devices[tempDevice.serialNumber] = tempDevice; // Store processed device
         }
       });
@@ -1971,9 +1763,10 @@ export default class NestAccfactory {
       let processed = {};
       try {
         // Fix up data we need to
-        data = process_common_data(object_key, data);
-        data.device_type = NestAccfactory.DeviceType.TEMPSENSOR; // Nest Temperature sensor
+        data.device_type = DeviceType.TEMPSENSOR; // Nest Temperature sensor
         data.model = 'Temperature Sensor';
+        data.softwareVersion = '1.0.0';
+        data = process_common_data(object_key, data);
         data.current_temperature = adjustTemperature(data.current_temperature, 'C', 'C', true);
         processed = data;
         // eslint-disable-next-line no-unused-vars
@@ -1994,8 +1787,8 @@ export default class NestAccfactory {
         let tempDevice = {};
         try {
           if (
-            value?.source === NestAccfactory.DataSource.PROTOBUF &&
-            this.config.options?.protobufAPI === true &&
+            value?.source === DATASOURCE.ProtobufAPI &&
+            this.config.options?.useGoogleAPI === true &&
             value.value?.configuration_done?.deviceReady === true &&
             typeof value?.value?.associated_thermostat === 'string' &&
             value?.value?.associated_thermostat !== ''
@@ -2005,8 +1798,9 @@ export default class NestAccfactory {
             // Guessing battery minimum voltage is 2v??
             RESTTypeData.battery_level = scaleValue(Number(value.value.battery.assessedVoltage.value), 2.0, 3.0, 0, 100);
             RESTTypeData.current_temperature = value.value.current_temperature.temperatureValue.temperature.value;
-            // Online status we 'faked' when processing Thermostat Protobuf data
-            RESTTypeData.online = value.value?.liveness?.status === 'LIVENESS_DEVICE_STATUS_ONLINE';
+            RESTTypeData.online =
+              isNaN(value.value?.last_updated_beacon?.lastBeaconTime?.seconds) === false &&
+              Math.floor(Date.now() / 1000) - Number(value.value.last_updated_beacon.lastBeaconTime.seconds) < 3600 * 4;
             RESTTypeData.associated_thermostat = value.value.associated_thermostat;
             RESTTypeData.description = typeof value.value?.label?.label === 'string' ? value.value.label.label : '';
             RESTTypeData.location = get_location_name(
@@ -2019,8 +1813,8 @@ export default class NestAccfactory {
             tempDevice = process_kryptonite_data(object_key, RESTTypeData);
           }
           if (
-            value?.source === NestAccfactory.DataSource.REST &&
-            this.config.options?.restAPI === true &&
+            value?.source === DATASOURCE.NestAPI &&
+            this.config.options?.useNestAPI === true &&
             value.value?.where_id !== undefined &&
             value.value?.structure_id !== undefined &&
             typeof value?.value?.associated_thermostat === 'string' &&
@@ -2030,7 +1824,7 @@ export default class NestAccfactory {
             RESTTypeData.serialNumber = value.value.serial_number;
             RESTTypeData.battery_level = scaleValue(Number(value.value.battery_level), 0, 100, 0, 100);
             RESTTypeData.current_temperature = value.value.current_temperature;
-            RESTTypeData.online = Math.floor(Date.now() / 1000) - value.value.last_updated_at < 3600 * 4 ? true : false;
+            RESTTypeData.online = Math.floor(Date.now() / 1000) - value.value.last_updated_at < 3600 * 4;
             RESTTypeData.associated_thermostat = value.value.associated_thermostat;
             RESTTypeData.description = value.value.description;
             RESTTypeData.location = get_location_name(value.value.structure_id, value.value.where_id);
@@ -2041,36 +1835,88 @@ export default class NestAccfactory {
           }
           // eslint-disable-next-line no-unused-vars
         } catch (error) {
-          this?.log?.debug && this.log.debug('Error processing data for temperature sensor(s)');
+          this?.log?.debug?.('Error processing data for temperature sensor(s)');
         }
         if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serialNumber] === 'undefined') {
+          let deviceOptions = this.config?.devices?.find(
+            (device) => device?.serialNumber?.toUpperCase?.() === tempDevice?.serialNumber?.toUpperCase?.(),
+          );
           // Insert any extra options we've read in from configuration file for this device
-          tempDevice.eveHistory =
-            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serialNumber]?.eveHistory === true;
+          tempDevice.eveHistory = this.config.options.eveHistory === true || deviceOptions?.eveHistory === true;
           devices[tempDevice.serialNumber] = tempDevice; // Store processed device
         }
       });
 
-    // Process data for any smoke detectors we have in the raw data
-    const process_protect_data = (object_key, data) => {
+    // Process data for any heatlink devices we have in the raw data
+    const process_heatlink_data = (object_key, data) => {
       let processed = {};
       try {
         // Fix up data we need to
+        data.device_type = DeviceType.HEATLINK;
         data = process_common_data(object_key, data);
-        data.device_type = NestAccfactory.DeviceType.SMOKESENSOR; // Nest Protect
-        data.model = 'Protect';
-        if (data.wired_or_battery === 0) {
-          data.model = data.model + ' (wired'; // Mains powered
-        }
-        if (data.wired_or_battery === 1) {
-          data.model = data.model + ' (battery'; // Battery powered
-        }
-        if (data.serialNumber.substring(0, 2) === '06') {
-          data.model = data.model + ', 2nd gen)'; // Nest Protect 2nd Gen
+        data.current_temperature = adjustTemperature(data.current_temperature, 'C', 'C', true);
+        processed = data;
+        // eslint-disable-next-line no-unused-vars
+      } catch (error) {
+        // Empty
+      }
+      return processed;
+    };
+
+    Object.entries(this.#rawData)
+      .filter(
+        ([key, value]) =>
+          key.startsWith('DEVICE_') === true &&
+          value.value?.device_info?.typeName === 'nest.resource.NestAgateHeatlinkResource' &&
+          (deviceUUID === '' || deviceUUID === key),
+      )
+      .forEach(([object_key, value]) => {
+        let tempDevice = {};
+        try {
+          if (
+            value?.source === DATASOURCE.ProtobufAPI &&
+            this.config.options?.useGoogleAPI === true &&
+            value.value?.configuration_done?.deviceReady === true
+          ) {
+            let RESTTypeData = {};
+            RESTTypeData.serialNumber = value.value.device_identity.serialNumber;
+            RESTTypeData.softwareVersion = value.value.device_identity.softwareVersion;
+            RESTTypeData.model = 'Heatlink (unknown)';
+            if (value.value.device_info.typeName === 'nest.resource.NestAgateHeatlinkResource') {
+              RESTTypeData.model = 'Heatlink';
+            }
+            RESTTypeData.battery_level = 100; // Not sure what it is
+            RESTTypeData.current_temperature = value.value.temperature.temperatureValue.temperature.value;
+            RESTTypeData.online = value.value?.liveness?.status === 'LIVENESS_DEVICE_STATUS_ONLINE';
+            RESTTypeData.description = typeof value.value?.label?.label === 'string' ? value.value.label.label : '';
+            RESTTypeData.location = get_location_name(
+              value.value?.device_info?.pairerId?.resourceId,
+              value.value?.device_located_settings?.whereAnnotationRid?.resourceId,
+            );
+            RESTTypeData.active_sensor = true; // This should be active always?
+            tempDevice = process_heatlink_data(object_key, RESTTypeData);
+          }
+          // eslint-disable-next-line no-unused-vars
+        } catch (error) {
+          this?.log?.debug?.('Error processing data for heatlink(s)');
         }
-        if (data.serialNumber.substring(0, 2) === '05') {
-          data.model = data.model + ', 1st gen)'; // Nest Protect 1st Gen
+        if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serialNumber] === 'undefined') {
+          let deviceOptions = this.config?.devices?.find(
+            (device) => device?.serialNumber?.toUpperCase?.() === tempDevice?.serialNumber?.toUpperCase?.(),
+          );
+          // Insert any extra options we've read in from configuration file for this device
+          tempDevice.eveHistory = this.config.options.eveHistory === true || deviceOptions?.eveHistory === true;
+          devices[tempDevice.serialNumber] = tempDevice; // Store processed device
         }
+      });
+
+    // Process data for any smoke detectors we have in the raw data
+    const process_protect_data = (object_key, data) => {
+      let processed = {};
+      try {
+        // Fix up data we need to
+        data.device_type = DeviceType.SMOKESENSOR; // Nest Protect
+        data = process_common_data(object_key, data);
         processed = data;
         // eslint-disable-next-line no-unused-vars
       } catch (error) {
@@ -2079,27 +1925,44 @@ export default class NestAccfactory {
       return processed;
     };
 
+    const PROTOBUF_PROTECT_RESOURCES = [
+      'nest.resource.NestProtect1LinePoweredResource',
+      'nest.resource.NestProtect1BatteryPoweredResource',
+      'nest.resource.NestProtect2LinePoweredResource',
+      'nest.resource.NestProtect2BatteryPoweredResource',
+      'NestProtect2Resource',
+    ];
     Object.entries(this.#rawData)
       .filter(
         ([key, value]) =>
           (key.startsWith('topaz.') === true ||
-            (key.startsWith('DEVICE_') === true && value.value?.device_info?.className.startsWith('topaz') === true)) &&
+            (key.startsWith('DEVICE_') === true && PROTOBUF_PROTECT_RESOURCES.includes(value.value?.device_info?.typeName) === true)) &&
           (deviceUUID === '' || deviceUUID === key),
       )
       .forEach(([object_key, value]) => {
         let tempDevice = {};
         try {
           if (
-            value?.source === NestAccfactory.DataSource.PROTOBUF &&
-            this.config.options?.protobufAPI === true &&
+            value?.source === DATASOURCE.ProtobufAPI &&
+            this.config.options?.useGoogleAPI === true &&
             value.value?.configuration_done?.deviceReady === true
           ) {
             let RESTTypeData = {};
             RESTTypeData.serialNumber = value.value.device_identity.serialNumber;
-            RESTTypeData.softwareVersion =
-              value.value.device_identity.softwareVersion.split(/\s+/)?.[3] !== undefined
-                ? value.value.device_identity.softwareVersion.split(/\s+/)?.[3]
-                : value.value.device_identity.softwareVersion;
+            RESTTypeData.softwareVersion = value.value.device_identity.softwareVersion;
+            RESTTypeData.model = 'Protect (unknown)';
+            if (value.value.device_info.typeName === 'nest.resource.NestProtect1LinePoweredResource') {
+              RESTTypeData.model = 'Protect (1st gen, wired)';
+            }
+            if (value.value.device_info.typeName === 'nest.resource.NestProtect1BatteryPoweredResource') {
+              RESTTypeData.model = 'Protect (1st gen, battery)';
+            }
+            if (value.value.device_info.typeName === 'nest.resource.NestProtect2LinePoweredResource') {
+              RESTTypeData.model = 'Protect (2nd gen, wired)';
+            }
+            if (value.value.device_info.typeName === 'nest.resource.NestProtect2BatteryPoweredResource') {
+              RESTTypeData.model = 'Protect (2nd gen, battery)';
+            }
             RESTTypeData.online = value.value?.liveness?.status === 'LIVENESS_DEVICE_STATUS_ONLINE';
             RESTTypeData.line_power_present = value.value?.wall_power?.status === 'POWER_SOURCE_STATUS_ACTIVE';
             RESTTypeData.wired_or_battery = typeof value.value?.wall_power?.status === 'string' ? 0 : 1;
@@ -2114,7 +1977,7 @@ export default class NestAccfactory {
                 : 1;
             RESTTypeData.smoke_status = value.value?.safety_alarm_smoke?.alarmState === 'ALARM_STATE_ALARM';
             RESTTypeData.co_status = value.value?.safety_alarm_co?.alarmState === 'ALARM_STATE_ALARM';
-            RESTTypeData.heat_status = false; // To find in protobuf
+            RESTTypeData.heat_status = false; // TODO <- need to find in protobuf
             RESTTypeData.hushed_state =
               value.value?.safety_alarm_smoke?.silenceState === 'SILENCE_STATE_SILENCED' ||
               value.value?.safety_alarm_co?.silenceState === 'SILENCE_STATE_SILENCED';
@@ -2128,12 +1991,12 @@ export default class NestAccfactory {
                 ? value.value.safety_summary?.warningDevices?.failures.includes('FAILURE_TYPE_TEMP') === false
                 : true;
             RESTTypeData.latest_alarm_test =
-              isNaN(value.value.self_test?.lastMstEnd?.seconds) === false ? Number(value.value.self_test.lastMstEnd.seconds) : 0;
+              isNaN(value.value?.self_test?.lastMstEnd?.seconds) === false ? Number(value.value.self_test.lastMstEnd.seconds) : 0;
             RESTTypeData.self_test_in_progress =
               value.value?.legacy_structure_self_test?.mstInProgress === true ||
               value.value?.legacy_structure_self_test?.astInProgress === true;
             RESTTypeData.replacement_date =
-              isNaN(value.value.legacy_protect_device_settings?.replaceByDate?.seconds) === false
+              isNaN(value.value?.legacy_protect_device_settings?.replaceByDate?.seconds) === false
                 ? Number(value.value.legacy_protect_device_settings.replaceByDate.seconds)
                 : 0;
             RESTTypeData.topaz_hush_key =
@@ -2149,14 +2012,27 @@ export default class NestAccfactory {
             tempDevice = process_protect_data(object_key, RESTTypeData);
           }
           if (
-            value?.source === NestAccfactory.DataSource.REST &&
-            this.config.options?.restAPI === true &&
+            value?.source === DATASOURCE.NestAPI &&
+            this.config.options?.useNestAPI === true &&
             value.value?.where_id !== undefined &&
             value.value?.structure_id !== undefined
           ) {
             let RESTTypeData = {};
             RESTTypeData.serialNumber = value.value.serial_number;
             RESTTypeData.softwareVersion = value.value.software_version;
+            RESTTypeData.model = 'Protect (unknown)';
+            if (RESTTypeData.serialNumber.substring(0, 2) === '06') {
+              RESTTypeData.model = 'Protect (2nd gen)'; // Nest Protect 2nd gen
+            }
+            if (RESTTypeData.serialNumber.substring(0, 2) === '05') {
+              RESTTypeData.model = 'Protect (1st gen)'; // Nest Protect 1st gen
+            }
+            RESTTypeData.model =
+              value.value.wired_or_battery === 1
+                ? RESTTypeData.model.replace(/\bgen\)/, 'gen, battery)')
+                : value.value.wired_or_battery === 0
+                  ? RESTTypeData.model.replace(/\bgen\)/, 'gen, wired)')
+                  : RESTTypeData.model;
             RESTTypeData.online =
               typeof value?.value?.thread_mac_address === 'string'
                 ? this.#rawData?.['widget_track.' + value?.value?.thread_mac_address.toUpperCase()]?.value?.online === true
@@ -2187,13 +2063,15 @@ export default class NestAccfactory {
           }
           // eslint-disable-next-line no-unused-vars
         } catch (error) {
-          this?.log?.debug && this.log.debug('Error processing data for smoke sensor(s)');
+          this?.log?.debug?.('Error processing data for smoke sensor(s)');
         }
 
         if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serialNumber] === 'undefined') {
+          let deviceOptions = this.config?.devices?.find(
+            (device) => device?.serialNumber?.toUpperCase?.() === tempDevice?.serialNumber?.toUpperCase?.(),
+          );
           // Insert any extra options we've read in from configuration file for this device
-          tempDevice.eveHistory =
-            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serialNumber]?.eveHistory === true;
+          tempDevice.eveHistory = this.config.options.eveHistory === true || deviceOptions?.eveHistory === true;
           devices[tempDevice.serialNumber] = tempDevice; // Store processed device
         }
       });
@@ -2203,14 +2081,14 @@ export default class NestAccfactory {
       let processed = {};
       try {
         // Fix up data we need to
-        data = process_common_data(object_key, data);
-        data.device_type = NestAccfactory.DeviceType.CAMERA;
+        data.device_type = DeviceType.CAMERA;
         if (data.model.toUpperCase().includes('DOORBELL') === true) {
-          data.device_type = NestAccfactory.DeviceType.DOORBELL;
+          data.device_type = DeviceType.DOORBELL;
         }
         if (data.model.toUpperCase().includes('FLOODLIGHT') === true) {
-          data.device_type = NestAccfactory.DeviceType.FLOODLIGHT;
+          data.device_type = DeviceType.FLOODLIGHT;
         }
+        data = process_common_data(object_key, data);
         processed = data;
         // eslint-disable-next-line no-unused-vars
       } catch (error) {
@@ -2242,8 +2120,8 @@ export default class NestAccfactory {
         let tempDevice = {};
         try {
           if (
-            value?.source === NestAccfactory.DataSource.PROTOBUF &&
-            this.config.options?.protobufAPI === true &&
+            value?.source === DATASOURCE.ProtobufAPI &&
+            this.config.options?.useGoogleAPI === true &&
             Array.isArray(value.value?.streaming_protocol?.supportedProtocols) === true &&
             value.value.streaming_protocol.supportedProtocols.includes('PROTOCOL_WEBRTC') === true &&
             (value.value?.configuration_done?.deviceReady === true ||
@@ -2251,15 +2129,8 @@ export default class NestAccfactory {
           ) {
             let RESTTypeData = {};
             RESTTypeData.serialNumber = value.value.device_identity.serialNumber;
-
-            // Protobuf camera firmware versions appear in alonger string. Seems the '4th' word in the string is the actual number version
-            // ie: rquartz-user 1 OPENMASTER 507800056 test-keys stable-channel stable-channel
-            // ie: nq-user 1.73 OPENMASTER 422270 release-keys stable-channel stable-channel
-            RESTTypeData.softwareVersion =
-              value.value.device_identity.softwareVersion.split(/\s+/)?.[3] !== undefined
-                ? value.value.device_identity.softwareVersion.split(/\s+/)?.[3]
-                : value.value.device_identity.softwareVersion;
-            RESTTypeData.model = 'Camera';
+            RESTTypeData.softwareVersion = value.value.device_identity.softwareVersion;
+            RESTTypeData.model = 'Camera (unknown)';
             if (
               value.value.device_info.typeName === 'google.resource.NeonQuartzResource' &&
               value.value?.floodlight_settings === undefined &&
@@ -2268,13 +2139,13 @@ export default class NestAccfactory {
               RESTTypeData.model = 'Cam (battery)';
             }
             if (value.value.device_info.typeName === 'google.resource.GreenQuartzResource') {
-              RESTTypeData.model = 'Doorbell (battery)';
+              RESTTypeData.model = 'Doorbell (2nd gen, battery)';
             }
             if (value.value.device_info.typeName === 'google.resource.SpencerResource') {
               RESTTypeData.model = 'Cam (wired)';
             }
             if (value.value.device_info.typeName === 'google.resource.VenusResource') {
-              RESTTypeData.model = 'Doorbell (wired, 2nd gen)';
+              RESTTypeData.model = 'Doorbell (2nd gen, wired)';
             }
             if (value.value.device_info.typeName === 'nest.resource.NestCamIndoorResource') {
               RESTTypeData.model = 'Cam Indoor (1st gen)';
@@ -2286,14 +2157,14 @@ export default class NestAccfactory {
               RESTTypeData.model = 'Cam Outdoor (1st gen)';
             }
             if (value.value.device_info.typeName === 'nest.resource.NestHelloResource') {
-              RESTTypeData.model = 'Doorbell (wired, 1st gen)';
+              RESTTypeData.model = 'Doorbell (1st gen, wired)';
             }
             if (
               value.value.device_info.typeName === 'google.resource.NeonQuartzResource' &&
               value.value?.floodlight_settings !== undefined &&
               value.value?.floodlight_state !== undefined
             ) {
-              RESTTypeData.model = 'Cam with Floodlight (wired)';
+              RESTTypeData.model = 'Cam with Floodlight';
             }
 
             RESTTypeData.online = value.value?.liveness?.status === 'LIVENESS_DEVICE_STATUS_ONLINE';
@@ -2308,6 +2179,7 @@ export default class NestAccfactory {
               value.value?.doorbell_indoor_chime_settings?.chimeType === 'CHIME_TYPE_ELECTRONIC';
             RESTTypeData.indoor_chime_enabled = value.value?.doorbell_indoor_chime_settings?.chimeEnabled === true;
             RESTTypeData.streaming_enabled = value.value?.recording_toggle?.currentCameraState === 'CAMERA_ON';
+            // Still need to find below in protobuf
             //RESTTypeData.has_irled =
             //RESTTypeData.irled_enabled =
             //RESTTypeData.has_statusled =
@@ -2328,8 +2200,9 @@ export default class NestAccfactory {
             }
             RESTTypeData.alerts = typeof value.value?.alerts === 'object' ? value.value.alerts : [];
             RESTTypeData.quiet_time_enabled =
-              parseInt(value.value?.quiet_time_settings?.quietTimeEnds?.seconds) !== 0 &&
-              Math.floor(Date.now() / 1000) < parseInt(value.value?.quiet_time_settings?.quietTimeEnds?.second);
+              isNaN(value.value?.quiet_time_settings?.quietTimeEnds?.seconds) === false &&
+              Number(value.value.quiet_time_settings.quietTimeEnds.seconds) !== 0 &&
+              Math.floor(Date.now() / 1000) < Number(value.value.quiet_time_settings.quietTimeEnds.second);
             RESTTypeData.camera_type = value.value.device_identity.vendorProductId;
             RESTTypeData.streaming_protocols =
               value.value?.streaming_protocol?.supportedProtocols !== undefined ? value.value.streaming_protocol.supportedProtocols : [];
@@ -2340,7 +2213,7 @@ export default class NestAccfactory {
             RESTTypeData.has_light = value.value?.floodlight_settings !== undefined && value.value?.floodlight_state !== undefined;
             RESTTypeData.light_enabled = value.value?.floodlight_state?.currentState === 'LIGHT_STATE_ON';
             RESTTypeData.light_brightness =
-              value.value?.floodlight_settings?.brightness !== undefined
+              isNaN(value.value?.floodlight_settings?.brightness) === false
                 ? scaleValue(Number(value.value.floodlight_settings.brightness), 0, 10, 0, 100)
                 : 0;
 
@@ -2357,15 +2230,15 @@ export default class NestAccfactory {
           }
 
           if (
-            value?.source === NestAccfactory.DataSource.REST &&
-            this.config.options?.restAPI === true &&
+            value?.source === DATASOURCE.NestAPI &&
+            this.config.options?.useNestAPI === true &&
             value.value?.where_id !== undefined &&
             value.value?.structure_id !== undefined &&
             value.value?.nexus_api_http_server_url !== undefined &&
             (value.value?.properties?.['cc2migration.overview_state'] === 'NORMAL' ||
               value.value?.properties?.['cc2migration.overview_state'] === 'REVERSE_MIGRATION_IN_PROGRESS')
           ) {
-            // We'll only use the REST API data for Camera's which have NOT been migrated to Google Home
+            // We'll only use the Nest API data for Camera's which have NOT been migrated to Google Home
             let RESTTypeData = {};
             RESTTypeData.serialNumber = value.value.serial_number;
             RESTTypeData.softwareVersion = value.value.software_version;
@@ -2385,7 +2258,7 @@ export default class NestAccfactory {
             RESTTypeData.video_flipped = value.value?.properties['video.flipped'] === true;
             RESTTypeData.statusled_brightness =
               isNaN(value.value?.properties?.['statusled.brightness']) === false
-                ? Number(value.value?.properties['statusled.brightness'])
+                ? Number(value.value.properties['statusled.brightness'])
                 : 0;
             RESTTypeData.has_microphone = value.value?.capabilities.includes('audio.microphone') === true;
             RESTTypeData.has_speaker = value.value?.capabilities.includes('audio.speaker') === true;
@@ -2409,55 +2282,43 @@ export default class NestAccfactory {
           }
           // eslint-disable-next-line no-unused-vars
         } catch (error) {
-          this?.log?.debug && this.log.debug('Error processing data for camera/doorbell(s)');
+          this?.log?.debug?.('Error processing data for camera/doorbell(s)');
         }
 
         if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serialNumber] === 'undefined') {
+          let deviceOptions = this.config?.devices?.find(
+            (device) => device?.serialNumber?.toUpperCase?.() === tempDevice?.serialNumber?.toUpperCase?.(),
+          );
           // Insert any extra options we've read in from configuration file for this device
-          tempDevice.eveHistory =
-            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serialNumber]?.eveHistory === true;
-          tempDevice.hksv = this.config.options.hksv === true || this.config?.devices?.[tempDevice.serialNumber]?.hksv === true;
-          tempDevice.doorbellCooldown =
-            isNaN(this.config?.devices?.[tempDevice.serialNumber]?.doorbellCooldown) === false
-              ? Number(this.config.devices[tempDevice.serialNumber].doorbellCooldown)
-              : 60;
-          tempDevice.motionCooldown =
-            isNaN(this.config?.devices?.[tempDevice.serialNumber]?.motionCooldown) === false
-              ? Number(this.config.devices[tempDevice.serialNumber].motionCooldown)
-              : 60;
-          tempDevice.personCooldown =
-            isNaN(this.config?.devices?.[tempDevice.serialNumber]?.personCooldown) === false
-              ? Number(this.config.devices[tempDevice.serialNumber].personCooldown)
-              : 120;
-          tempDevice.chimeSwitch = this.config?.devices?.[tempDevice.serialNumber]?.chimeSwitch === true; // Control 'indoor' chime by switch
-          tempDevice.localAccess = this.config?.devices?.[tempDevice.serialNumber]?.localAccess === true; // Local network video streaming rather than from cloud from camera/doorbells
+          tempDevice.eveHistory = this.config.options.eveHistory === true || deviceOptions?.eveHistory === true;
+          tempDevice.hksv = this.config.options.hksv === true || deviceOptions?.hksv === true;
+          tempDevice.doorbellCooldown = parseDurationToSeconds(deviceOptions?.doorbellCooldown, { defaultValue: 60, min: 0, max: 300 });
+          tempDevice.motionCooldown = parseDurationToSeconds(deviceOptions?.motionCooldown, { defaultValue: 60, min: 0, max: 300 });
+          tempDevice.personCooldown = parseDurationToSeconds(deviceOptions?.personCooldown, { defaultValue: 120, min: 0, max: 300 });
+          tempDevice.chimeSwitch = deviceOptions?.chimeSwitch === true; // Control 'indoor' chime by switch
+          tempDevice.localAccess = deviceOptions?.localAccess === true; // Local network video streaming rather than from cloud from camera/doorbells
           // eslint-disable-next-line no-undef
           tempDevice.ffmpeg = structuredClone(this.config.options.ffmpeg); // ffmpeg details, path, libraries. No ffmpeg = undefined
-          if (this.config?.devices?.[tempDevice.serialNumber]?.ffmpegDebug !== undefined) {
+          if (deviceOptions?.ffmpegDebug !== undefined) {
             // Device specific ffmpeg debugging
-            tempDevice.ffmpeg.debug = this.config?.devices?.[tempDevice.serialNumber]?.ffmpegDebug === true;
+            tempDevice.ffmpeg.debug = deviceOptions?.ffmpegDebug === true;
           }
-          tempDevice.maxStreams =
-            isNaN(this.config.options?.maxStreams) === false
-              ? Number(this.config.options.maxStreams)
-              : this.deviceData.hksv === true
-                ? 1
-                : 2;
-
+          tempDevice.maxStreams = this.config.options.hksv === true || deviceOptions?.hksv === true ? 1 : 2;
           devices[tempDevice.serialNumber] = tempDevice; // Store processed device
         }
       });
 
-    // Process data for any structure(s) for both REST and Protobuf API data
+    // Process data for any structure(s) for both Nest and Protobuf API data
     // We use this to created virtual weather station(s) for each structure that has location data
     const process_structure_data = (object_key, data) => {
       let processed = {};
       try {
         // Fix up data we need to
-        data = process_common_data(object_key, data);
-        data.device_type = NestAccfactory.DeviceType.WEATHER;
+        data.device_type = DeviceType.WEATHER;
         data.model = 'Weather';
-        data.current_temperature = data.weather.current_temperature;
+        data.softwareVersion = '1.0.0';
+        data = process_common_data(object_key, data);
+        data.current_temperature = adjustTemperature(data.weather.current_temperature, 'C', 'C', true);
         data.current_humidity = data.weather.current_humidity;
         data.condition = data.weather.condition;
         data.wind_direction = data.weather.wind_direction;
@@ -2466,12 +2327,6 @@ export default class NestAccfactory {
         data.sunset = data.weather.sunset;
         data.station = data.weather.station;
         data.forecast = data.weather.forecast;
-        data.elevation =
-          isNaN(this.config?.devices?.[data?.serial_number]?.elevation) === false
-            ? Number(this.config.devices[data.serial_number].elevation)
-            : isNaN(this.config?.options?.elevation) === false
-              ? Number(this.config.options.elevation)
-              : 0;
         processed = data;
         // eslint-disable-next-line no-unused-vars
       } catch (error) {
@@ -2491,8 +2346,8 @@ export default class NestAccfactory {
         let tempDevice = {};
         try {
           if (
-            value?.source === NestAccfactory.DataSource.PROTOBUF &&
-            this.config.options?.protobufAPI === true &&
+            value?.source === DATASOURCE.ProtobufAPI &&
+            this.config.options?.useGoogleAPI === true &&
             value.value?.structure_location?.geoCoordinate?.latitude !== undefined &&
             value.value?.structure_location?.geoCoordinate?.longitude !== undefined
           ) {
@@ -2510,14 +2365,14 @@ export default class NestAccfactory {
                 : value.value.structure_info.name;
             RESTTypeData.weather = value.value.weather;
 
-            // Use the REST API structure ID from the Protobuf structure. This will ensure we generate the same serial number
+            // Use the Nest API structure ID from the Protobuf structure. This will ensure we generate the same serial number
             // This should prevent two 'weather' objects being created
             tempDevice = process_structure_data(object_key, RESTTypeData);
           }
 
           if (
-            value?.source === NestAccfactory.DataSource.REST &&
-            this.config.options?.restAPI === true &&
+            value?.source === DATASOURCE.NestAPI &&
+            this.config.options?.useNestAPI === true &&
             value.value?.latitude !== undefined &&
             value.value?.longitude !== undefined
           ) {
@@ -2536,13 +2391,19 @@ export default class NestAccfactory {
           }
           // eslint-disable-next-line no-unused-vars
         } catch (error) {
-          this?.log?.debug && this.log.debug('Error processing data for weather');
+          this?.log?.debug?.('Error processing data for weather');
         }
 
         if (Object.entries(tempDevice).length !== 0 && typeof devices[tempDevice.serialNumber] === 'undefined') {
+          let deviceOptions = this.config?.devices?.find(
+            (device) => device?.serialNumber?.toUpperCase?.() === tempDevice?.serialNumber?.toUpperCase?.(),
+          );
           // Insert any extra options we've read in from configuration file for this device
-          tempDevice.eveHistory =
-            this.config.options.eveHistory === true || this.config?.devices?.[tempDevice.serialNumber]?.eveHistory === true;
+          tempDevice.eveHistory = this.config.options.eveHistory === true || deviceOptions?.eveHistory === true;
+          tempDevice.elevation =
+            isNaN(deviceOptions?.elevation) === false && Number(deviceOptions?.elevation) >= 0 && Number(deviceOptions?.elevation) <= 8848
+              ? Number(deviceOptions?.elevation)
+              : this.config.options.elevation;
           devices[tempDevice.serialNumber] = tempDevice; // Store processed device
         }
       });
@@ -2550,10 +2411,8 @@ export default class NestAccfactory {
     return devices; // Return our processed data
   }
 
-  async #set(uuid, values) {
+  async #set(values) {
     if (
-      typeof uuid !== 'string' ||
-      uuid === '' ||
       typeof values !== 'object' ||
       values?.uuid === undefined ||
       typeof this.#rawData?.[values?.uuid] !== 'object' ||
@@ -2563,9 +2422,9 @@ export default class NestAccfactory {
     }
 
     let nest_google_uuid = values.uuid; // Nest/Google structure uuid for this get request
-    let connectionUuid = this.#rawData[values.uuid].connection; // Associated connection uuid for the device
+    let uuid = this.#rawData[values.uuid].connection; // Connection uuid for this device
 
-    if (this.#protobufRoot !== null && this.#rawData?.[nest_google_uuid]?.source === NestAccfactory.DataSource.PROTOBUF) {
+    if (this.#protobufRoot !== null && this.#rawData?.[nest_google_uuid]?.source === DATASOURCE.ProtobufAPI) {
       let updatedTraits = [];
       let protobufElement = {
         traitRequest: {
@@ -2636,7 +2495,7 @@ export default class NestAccfactory {
                 protobufElement.state.value.enabled = { value: false };
               }
 
-              // Tag 'who is doing the temperature/mode change. We are :-)
+              // Tag 'who' is doing the temperature/mode change. We are :-)
               protobufElement.state.value.targetTemperature.currentActorInfo = {
                 method: 'HVAC_ACTOR_METHOD_IOS',
                 originator: this.#rawData[nest_google_uuid].value.target_temperature_settings.targetTemperature.currentActorInfo.originator,
@@ -2709,9 +2568,11 @@ export default class NestAccfactory {
               protobufElement.state.value.timerEnd =
                 value === true
                   ? {
-                      seconds: Number(Math.floor(Date.now() / 1000 + Number(protobufElement.state.value.timerDuration.seconds))),
-                      nanos: (Math.floor(Date.now() / 1000 + Number(protobufElement.state.value.timerDuration.seconds)) % 1000) * 1e6,
-                    }
+                    seconds: Number(Math.floor(Date.now() / 1000) + Number(protobufElement.state.value.timerDuration.seconds)),
+                    nanos: Number(
+                      ((Math.floor(Date.now() / 1000) + Number(protobufElement.state.value.timerDuration.seconds)) % 1000) * 1e6,
+                    ),
+                  }
                   : { seconds: 0, nanos: 0 };
               if (values?.fan_timer_speed !== undefined) {
                 // We have a value to set fan speed also, so handle here as combined setting
@@ -2748,7 +2609,10 @@ export default class NestAccfactory {
               protobufElement.state.value = this.#rawData[nest_google_uuid].value.recording_toggle_settings;
               protobufElement.state.value.targetCameraState = value === true ? 'CAMERA_ON' : 'CAMERA_OFF';
               protobufElement.state.value.changeModeReason = 2;
-              protobufElement.state.value.settingsUpdated = { seconds: Math.floor(Date.now() / 1000), nanos: (Date.now() % 1000) * 1e6 };
+              protobufElement.state.value.settingsUpdated = {
+                seconds: Math.floor(Date.now() / 1000),
+                nanos: (Date.now() % 1000) * 1e6,
+              };
             }
 
             if (key === 'audio_enabled' && typeof value === 'boolean') {
@@ -2781,7 +2645,7 @@ export default class NestAccfactory {
                 });
 
                 if (serviceUUID !== undefined) {
-                  let commandResponse = await this.#protobufCommand(connectionUuid, 'ResourceApi', 'SendCommand', {
+                  let commandResponse = await this.#protobufCommand(uuid, 'ResourceApi', 'SendCommand', {
                     resourceRequest: {
                       resourceId: serviceUUID,
                       requestId: crypto.randomUUID(),
@@ -2800,7 +2664,7 @@ export default class NestAccfactory {
                   });
 
                   if (commandResponse.sendCommandResponse?.[0]?.traitOperations?.[0]?.progress !== 'COMPLETE') {
-                    this?.log?.debug && this.log.debug('Protobuf API had error setting light status on uuid "%s"', nest_google_uuid);
+                    this?.log?.debug?.('Protobuf API had error setting light status on uuid "%s"', nest_google_uuid);
                   }
                 }
               }
@@ -2814,8 +2678,42 @@ export default class NestAccfactory {
               protobufElement.state.value.brightness = scaleValue(Number(value), 0, 100, 0, 10); // Scale to required level
             }
 
+            if (
+              key === 'active_sensor' &&
+              typeof value === 'boolean' &&
+              typeof this.#rawData?.[this.#rawData[nest_google_uuid]?.value?.associated_thermostat]?.value
+                ?.remote_comfort_sensing_settings === 'object'
+            ) {
+              // Set active temperature sensor for associated thermostat
+              protobufElement.traitRequest.resourceId = this.#rawData[nest_google_uuid].value.associated_thermostat;
+              protobufElement.traitRequest.traitLabel = 'remote_comfort_sensing_settings';
+              protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.hvac.RemoteComfortSensingSettingsTrait';
+              protobufElement.state.value =
+                this.#rawData[this.#rawData[nest_google_uuid].value.associated_thermostat].value.remote_comfort_sensing_settings;
+              protobufElement.state.value.activeRcsSelection =
+                value === true
+                  ? { rcsSourceType: 'RCS_SOURCE_TYPE_SINGLE_SENSOR', activeRcsSensor: { resourceId: nest_google_uuid } }
+                  : { rcsSourceType: 'RCS_SOURCE_TYPE_BACKPLATE' };
+            }
+
+            if (key === 'hot_water_boost_active' && typeof value === 'object') {
+              // Turn hotwater boost heating on/off
+              protobufElement.traitRequest.traitLabel = 'hot_water_settings';
+              protobufElement.state.type_url = 'type.nestlabs.com/nest.trait.hvac.HotWaterSettingsTrait';
+              protobufElement.state.value = this.#rawData[nest_google_uuid].value.hot_water_settings;
+              protobufElement.state.value.boostTimerEnd =
+                value?.state === true
+                  ? {
+                    seconds: Number(Math.floor(Date.now() / 1000) + Number(isNaN(value?.time) === false ? value?.time : 30 * 60)),
+                    nanos: Number(
+                      (Math.floor(Date.now() / 1000) + (Number(isNaN(value?.time) === false ? value?.time : 30 * 60) % 1000)) * 1e6,
+                    ),
+                  }
+                  : { seconds: 0, nanos: 0 };
+            }
+
             if (protobufElement.traitRequest.traitLabel === '' || protobufElement.state.type_url === '') {
-              this?.log?.debug && this.log.debug('Unknown Protobuf set key "%s" for device uuid "%s"', key, nest_google_uuid);
+              this?.log?.debug?.('Unknown Protobuf set key "%s" for device uuid "%s"', key, nest_google_uuid);
             }
 
             if (protobufElement.traitRequest.traitLabel !== '' && protobufElement.state.type_url !== '') {
@@ -2826,90 +2724,94 @@ export default class NestAccfactory {
       );
 
       if (updatedTraits.length !== 0) {
-        let commandResponse = await this.#protobufCommand(connectionUuid, 'TraitBatchApi', 'BatchUpdateState', {
+        let commandResponse = await this.#protobufCommand(uuid, 'TraitBatchApi', 'BatchUpdateState', {
           batchUpdateStateRequest: updatedTraits,
         });
         if (
           commandResponse === undefined ||
           commandResponse?.batchUpdateStateResponse?.[0]?.traitOperations?.[0]?.progress !== 'COMPLETE'
         ) {
-          this?.log?.debug && this.log.debug('Protobuf API had error updating device traits for uuid "%s"', nest_google_uuid);
+          this?.log?.debug?.('Protobuf API had error updating device traits for uuid "%s"', nest_google_uuid);
         }
       }
     }
 
-    if (this.#rawData?.[nest_google_uuid]?.source === NestAccfactory.DataSource.REST && nest_google_uuid.startsWith('quartz.') === true) {
+    if (this.#rawData?.[nest_google_uuid]?.source === DATASOURCE.NestAPI && nest_google_uuid.startsWith('quartz.') === true) {
       // Set value on Nest Camera/Doorbell
       await Promise.all(
         Object.entries(values)
           .filter(([key]) => key !== 'uuid')
           .map(async ([key, value]) => {
-            const SETPROPERTIES = {
-              indoor_chime_enabled: 'doorbell.indoor_chime.enabled',
-              statusled_brightness: 'statusled.brightness',
-              irled_enabled: 'irled.state',
-              streaming_enabled: 'streaming.enabled',
-              audio_enabled: 'audio.enabled',
-            };
-
-            // Transform key to correct set camera properties key
-            key = SETPROPERTIES[key] !== undefined ? SETPROPERTIES[key] : key;
-
-            await fetchWrapper(
-              'post',
-              'https://webapi.' + this.#connections[connectionUuid].cameraAPIHost + '/api/dropcams.set_properties',
+            let mappedKey =
               {
-                headers: {
-                  referer: 'https://' + this.#connections[connectionUuid].referer,
-                  'User-Agent': USERAGENT,
-                  'Content-Type': 'application/x-www-form-urlencoded',
-                  [this.#connections[connectionUuid].cameraAPI.key]:
-                    this.#connections[connectionUuid].cameraAPI.value + this.#connections[connectionUuid].cameraAPI.token,
+                indoor_chime_enabled: 'doorbell.indoor_chime.enabled',
+                statusled_brightness: 'statusled.brightness',
+                irled_enabled: 'irled.state',
+                streaming_enabled: 'streaming.enabled',
+                audio_enabled: 'audio.enabled',
+              }[key] ?? key;
+
+            try {
+              let response = await fetchWrapper(
+                'post',
+                'https://webapi.' + this.#connections[uuid].cameraAPIHost + '/api/dropcams.set_properties',
+                {
+                  headers: {
+                    referer: 'https://' + this.#connections[uuid].referer,
+                    'User-Agent': USERAGENT,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    [this.#connections[uuid].cameraAPI.key]:
+                      this.#connections[uuid].cameraAPI.value + this.#connections[uuid].cameraAPI.token,
+                  },
+                  timeout: NESTAPITIMEOUT,
                 },
-                timeout: NESTAPITIMEOUT,
-              },
-              [key] + '=' + value + '&uuid=' + nest_google_uuid.split('.')[1],
-            )
-              .then((response) => response.json())
-              .then((data) => {
-                if (data?.status !== 0) {
-                  throw new Error('REST API camera update for failed with error');
-                }
-              })
-              .catch((error) => {
-                if (
-                  error?.cause !== undefined &&
-                  JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false &&
-                  this?.log?.debug
-                ) {
-                  this.log.debug(
-                    'REST API camera update for failed with error for uuid "%s". Error was "%s"',
-                    nest_google_uuid,
-                    error?.code,
-                  );
-                }
-              });
+                mappedKey + '=' + value + '&uuid=' + nest_google_uuid.split('.')[1],
+              );
+
+              let data = await response.json();
+              if (data?.status !== 0) {
+                throw new Error('Nest API camera update failed');
+              }
+            } catch (error) {
+              if (error?.cause !== undefined && String(error.cause).toUpperCase().includes('TIMEOUT') === false) {
+                this?.log?.debug?.('Nest API camera update failed for uuid "%s". Error was "%s"', nest_google_uuid, error?.code);
+              }
+            }
           }),
       );
     }
 
-    if (this.#rawData?.[nest_google_uuid]?.source === NestAccfactory.DataSource.REST && nest_google_uuid.startsWith('quartz.') === false) {
+    if (this.#rawData?.[nest_google_uuid]?.source === DATASOURCE.NestAPI && nest_google_uuid.startsWith('quartz.') === false) {
       // set values on other Nest devices besides cameras/doorbells
       await Promise.all(
         Object.entries(values)
           .filter(([key]) => key !== 'uuid')
           .map(async ([key, value]) => {
             let subscribeJSONData = { objects: [] };
+            let RESTStructureUUID = nest_google_uuid;
 
-            if (nest_google_uuid.startsWith('device.') === false) {
-              subscribeJSONData.objects.push({ object_key: nest_google_uuid, op: 'MERGE', value: { [key]: value } });
+            if (nest_google_uuid.startsWith('kryptonite.') === true) {
+              if (
+                key === 'active_sensor' &&
+                typeof value === 'boolean' &&
+                typeof this.#rawData?.['rcs_settings.' + this.#rawData?.[nest_google_uuid]?.value?.associated_thermostat.split('.')[1]]
+                  ?.value?.active_rcs_sensors === 'object'
+              ) {
+                // Set active temperature sensor for associated thermostat
+                RESTStructureUUID = 'rcs_settings.' + this.#rawData[nest_google_uuid].value.associated_thermostat.split('.')[1];
+                subscribeJSONData.objects.push({
+                  object_key: RESTStructureUUID,
+                  op: 'MERGE',
+                  value:
+                    value === true
+                      ? { active_rcs_sensors: [nest_google_uuid], rcs_control_setting: 'OVERRIDE' }
+                      : { active_rcs_sensors: [], rcs_control_setting: 'OFF' },
+                });
+              }
             }
 
-            // Some elements when setting thermostat data are located in a different object location than with the device object
-            // Handle this scenario below
             if (nest_google_uuid.startsWith('device.') === true) {
-              let RESTStructureUUID = nest_google_uuid;
-
+              // Set thermostat settings. Some settings are located in a different ocject location, so we handle this below also
               if (
                 (key === 'hvac_mode' &&
                   typeof value === 'string' &&
@@ -2934,39 +2836,47 @@ export default class NestAccfactory {
                 value = value !== 0 ? 'stage' + value : 'stage1';
               }
 
+              if (key === 'hot_water_boost_active' && typeof value === 'object') {
+                key = 'hot_water_boost_time_to_end';
+                value =
+                  value?.state === true ? Number(isNaN(value?.time) === false ? value?.time : 30 * 60) + Math.floor(Date.now() / 1000) : 0;
+              }
+
               subscribeJSONData.objects.push({ object_key: RESTStructureUUID, op: 'MERGE', value: { [key]: value } });
             }
 
+            if (nest_google_uuid.startsWith('device.') === false && nest_google_uuid.startsWith('kryptonite.') === false) {
+              // Set other Nest object settings ie: not thermostat or temperature sensors
+              subscribeJSONData.objects.push({ object_key: nest_google_uuid, op: 'MERGE', value: { [key]: value } });
+            }
+
             if (subscribeJSONData.objects.length !== 0) {
-              await fetchWrapper(
-                'post',
-                this.#connections[connectionUuid].transport_url + '/v5/put',
-                {
-                  referer: 'https://' + this.#connections[connectionUuid].referer,
-                  headers: {
-                    'User-Agent': USERAGENT,
-                    Authorization: 'Basic ' + this.#connections[connectionUuid].token,
+              try {
+                await fetchWrapper(
+                  'post',
+                  this.#connections[uuid].transport_url + '/v5/put',
+                  {
+                    referer: 'https://' + this.#connections[uuid].referer,
+                    headers: {
+                      'User-Agent': USERAGENT,
+                      Authorization: 'Basic ' + this.#connections[uuid].token,
+                    },
                   },
-                },
-                JSON.stringify(subscribeJSONData),
-              ).catch((error) => {
-                this?.log?.debug &&
-                  this.log.debug(
-                    'REST API property update for failed with error for uuid "%s". Error was "%s"',
-                    nest_google_uuid,
-                    error?.code,
-                  );
-              });
+                  JSON.stringify(subscribeJSONData),
+                );
+              } catch (error) {
+                if (error?.cause !== undefined && String(error.cause).toUpperCase().includes('TIMEOUT') === false) {
+                  this?.log?.debug?.('Nest API property update failed for uuid "%s". Error was "%s"', nest_google_uuid, error?.code);
+                }
+              }
             }
           }),
       );
     }
   }
 
-  async #get(uuid, values) {
+  async #get(values) {
     if (
-      typeof uuid !== 'string' ||
-      uuid === '' ||
       typeof values !== 'object' ||
       values?.uuid === undefined ||
       typeof this.#rawData?.[values?.uuid] !== 'object' ||
@@ -2976,7 +2886,7 @@ export default class NestAccfactory {
     }
 
     let nest_google_uuid = values.uuid; // Nest/Google structure uuid for this get request
-    let connectionUuid = this.#rawData[values.uuid].connection; // Associated connection uuid for the uuid
+    let uuid = this.#rawData[values.uuid].connection; // Connection uuid for this device
 
     await Promise.all(
       Object.entries(values)
@@ -2987,50 +2897,48 @@ export default class NestAccfactory {
           values[key] = undefined;
 
           if (
-            this.#rawData?.[nest_google_uuid]?.source === NestAccfactory.DataSource.REST &&
+            this.#rawData?.[nest_google_uuid]?.source === DATASOURCE.NestAPI &&
             key === 'camera_snapshot' &&
             nest_google_uuid.startsWith('quartz.') === true &&
             typeof this.#rawData?.[nest_google_uuid]?.value?.nexus_api_http_server_url === 'string' &&
             this.#rawData[nest_google_uuid].value.nexus_api_http_server_url !== ''
           ) {
-            // Attempt to retrieve snapshot from camera via REST API
-            await fetchWrapper(
-              'get',
-              this.#rawData[nest_google_uuid].value.nexus_api_http_server_url + '/get_image?uuid=' + nest_google_uuid.split('.')[1],
-              {
-                headers: {
-                  referer: 'https://' + this.#connections[connectionUuid].referer,
-                  'User-Agent': USERAGENT,
-                  [this.#connections[connectionUuid].cameraAPI.key]:
-                    this.#connections[connectionUuid].cameraAPI.value + this.#connections[connectionUuid].cameraAPI.token,
+            // Attempt to retrieve snapshot from camera via Nest API
+            try {
+              let response = await fetchWrapper(
+                'get',
+                this.#rawData[nest_google_uuid].value.nexus_api_http_server_url + '/get_image?uuid=' + nest_google_uuid.split('.')[1],
+                {
+                  headers: {
+                    referer: 'https://' + this.#connections[uuid].referer,
+                    'User-Agent': USERAGENT,
+                    [this.#connections[uuid].cameraAPI.key]:
+                      this.#connections[uuid].cameraAPI.value + this.#connections[uuid].cameraAPI.token,
+                  },
+                  timeout: 3000,
                 },
-                timeout: 3000,
-              },
-            )
-              .then((response) => response.arrayBuffer())
-              .then((data) => {
-                values[key] = Buffer.from(data);
-              })
-              .catch((error) => {
-                if (
-                  error?.cause !== undefined &&
-                  JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false &&
-                  this?.log?.debug
-                ) {
-                  this.log.debug('REST API camera snapshot failed with error for uuid "%s". Error was "%s"', nest_google_uuid, error?.code);
-                }
-              });
+              );
+              values[key] = Buffer.from(await response.arrayBuffer());
+            } catch (error) {
+              if (error?.cause !== undefined && String(error.cause).toUpperCase().includes('TIMEOUT') === false) {
+                this?.log?.debug?.(
+                  'Nest API camera snapshot failed with error for uuid "%s". Error was "%s"',
+                  nest_google_uuid,
+                  error?.code,
+                );
+              }
+            }
           }
 
           if (
-            this.#rawData?.[nest_google_uuid]?.source === NestAccfactory.DataSource.PROTOBUF &&
+            this.#rawData?.[nest_google_uuid]?.source === DATASOURCE.ProtobufAPI &&
             this.#protobufRoot !== null &&
             this.#rawData[nest_google_uuid]?.value?.device_identity?.vendorProductId !== undefined &&
             key === 'camera_snapshot'
           ) {
             // Attempt to retrieve snapshot from camera via Protobuf API
             // First, request to get snapshot url image updated
-            let commandResponse = await this.#protobufCommand(connectionUuid, 'ResourceApi', 'SendCommand', {
+            let commandResponse = await this.#protobufCommand(uuid, 'ResourceApi', 'SendCommand', {
               resourceRequest: {
                 resourceId: nest_google_uuid,
                 requestId: crypto.randomUUID(),
@@ -3051,32 +2959,26 @@ export default class NestAccfactory {
               typeof this.#rawData?.[nest_google_uuid]?.value?.upload_live_image?.liveImageUrl === 'string' &&
               this.#rawData[nest_google_uuid].value.upload_live_image.liveImageUrl !== ''
             ) {
-              // Snapshot url image has beeen updated, so no retrieve it
-              await fetchWrapper('get', this.#rawData[nest_google_uuid].value.upload_live_image.liveImageUrl, {
-                referer: 'https://' + this.#connections[connectionUuid].referer,
-                headers: {
-                  'User-Agent': USERAGENT,
-                  Authorization: 'Basic ' + this.#connections[connectionUuid].token,
-                },
-                timeout: 3000,
-              })
-                .then((response) => response.arrayBuffer())
-                .then((data) => {
-                  values[key] = Buffer.from(data);
-                })
-                .catch((error) => {
-                  if (
-                    error?.cause !== undefined &&
-                    JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false &&
-                    this?.log?.debug
-                  ) {
-                    this.log.debug(
-                      'Protobuf API camera snapshot failed with error for uuid "%s". Error was "%s"',
-                      nest_google_uuid,
-                      error?.code,
-                    );
-                  }
+              // Snapshot url image has been updated, so now retrieve it
+              try {
+                let response = await fetchWrapper('get', this.#rawData[nest_google_uuid].value.upload_live_image.liveImageUrl, {
+                  referer: 'https://' + this.#connections[uuid].referer,
+                  headers: {
+                    'User-Agent': USERAGENT,
+                    Authorization: 'Basic ' + this.#connections[uuid].token,
+                  },
+                  timeout: 3000,
                 });
+                values[key] = Buffer.from(await response.arrayBuffer());
+              } catch (error) {
+                if (error?.cause !== undefined && String(error.cause).toUpperCase().includes('TIMEOUT') === false) {
+                  this?.log?.debug?.(
+                    'Protobuf API camera snapshot failed with error for uuid "%s". Error was "%s"',
+                    nest_google_uuid,
+                    error?.code,
+                  );
+                }
+              }
             }
           }
         }),
@@ -3085,79 +2987,83 @@ export default class NestAccfactory {
     return values;
   }
 
-  async #getWeatherData(connectionUUID, deviceUUID, latitude, longitude) {
-    let weatherData = {};
-    if (typeof this.#rawData[deviceUUID]?.value?.weather === 'object') {
-      weatherData = this.#rawData?.[deviceUUID]?.value.weather;
-    }
+  async #getWeather(uuid, deviceUUID, latitude, longitude) {
+    let weather = typeof this.#rawData?.[deviceUUID]?.value?.weather === 'object' ? this.#rawData[deviceUUID].value.weather : {};
 
-    if (typeof this.#connections?.[connectionUUID].weather_url === 'string' && this.#connections[connectionUUID].weather_url !== '') {
-      await fetchWrapper('get', this.#connections[connectionUUID].weather_url + latitude + ',' + longitude, {
-        referer: 'https://' + this.#connections[connectionUUID].referer,
-        headers: {
-          'User-Agent': USERAGENT,
-        },
-        timeout: NESTAPITIMEOUT,
-      })
-        .then((response) => response.json())
-        .then((data) => {
-          // Store the lat/long details in the weather data object
-          weatherData.latitude = latitude;
-          weatherData.longitude = longitude;
-
-          // Update weather data
-          if (data?.[latitude + ',' + longitude]?.current !== undefined) {
-            weatherData.current_temperature = adjustTemperature(data[latitude + ',' + longitude].current.temp_c, 'C', 'C', false);
-            weatherData.current_humidity = data[latitude + ',' + longitude].current.humidity;
-            weatherData.condition = data[latitude + ',' + longitude].current.condition;
-            weatherData.wind_direction = data[latitude + ',' + longitude].current.wind_dir;
-            weatherData.wind_speed = data[latitude + ',' + longitude].current.wind_mph * 1.609344; // convert to km/h
-            weatherData.sunrise = data[latitude + ',' + longitude].current.sunrise;
-            weatherData.sunset = data[latitude + ',' + longitude].current.sunset;
-          }
-          weatherData.station =
-            data[latitude + ',' + longitude]?.location?.short_name !== undefined
-              ? data[latitude + ',' + longitude].location.short_name
-              : '';
-          weatherData.forecast =
-            data[latitude + ',' + longitude]?.forecast?.daily?.[0]?.condition !== undefined
-              ? data[latitude + ',' + longitude].forecast.daily[0].condition
-              : '';
-        })
-        .catch((error) => {
-          if (error?.cause !== undefined && JSON.stringify(error.cause).toUpperCase().includes('TIMEOUT') === false && this?.log?.debug) {
-            this.log.debug('REST API failed to retrieve weather details for uuid "%s". Error was "%s"', deviceUUID, error?.code);
-          }
+    let location = latitude + ',' + longitude;
+
+    if (typeof this.#connections?.[uuid]?.weather_url === 'string' && this.#connections[uuid].weather_url !== '') {
+      try {
+        let response = await fetchWrapper('get', this.#connections[uuid].weather_url + location, {
+          referer: 'https://' + this.#connections[uuid].referer,
+          headers: {
+            'User-Agent': USERAGENT,
+          },
+          timeout: NESTAPITIMEOUT,
         });
+
+        let data = await response.json();
+        let locationData = data?.[location];
+
+        // Store the lat/long details in the weather data object
+        weather.latitude = latitude;
+        weather.longitude = longitude;
+
+        // Update weather data
+        if (locationData?.current !== undefined) {
+          weather.current_temperature = adjustTemperature(locationData.current.temp_c, 'C', 'C', false);
+          weather.current_humidity = locationData.current.humidity;
+          weather.condition = locationData.current.condition;
+          weather.wind_direction = locationData.current.wind_dir;
+          weather.wind_speed = locationData.current.wind_mph * 1.609344; // convert to km/h
+          weather.sunrise = locationData.current.sunrise;
+          weather.sunset = locationData.current.sunset;
+        }
+
+        weather.station = typeof locationData?.location?.short_name === 'string' ? locationData.location.short_name : '';
+        weather.forecast = locationData?.forecast?.daily?.[0]?.condition !== undefined ? locationData.forecast.daily[0].condition : '';
+      } catch (error) {
+        if (error?.cause !== undefined && String(error.cause).toUpperCase().includes('TIMEOUT') === false) {
+          this?.log?.debug?.('Nest API failed to retrieve weather details for uuid "%s". Error was "%s"', deviceUUID, error?.code);
+        }
+      }
     }
 
-    return weatherData;
+    return weather;
   }
 
-  async #protobufCommand(connectionUUID, service, command, values) {
+  async #protobufCommand(uuid, service, command, values) {
     if (
       this.#protobufRoot === null ||
+      typeof uuid !== 'string' ||
+      !uuid ||
       typeof service !== 'string' ||
-      service === '' ||
+      !service ||
       typeof command !== 'string' ||
-      command === '' ||
-      typeof values !== 'object'
+      !command ||
+      typeof values !== 'object' ||
+      values === null ||
+      this.#connections?.[uuid] === undefined ||
+      typeof this.#connections?.[uuid].protobufAPIHost !== 'string' ||
+      typeof this.#connections?.[uuid].referer !== 'string' ||
+      typeof this.#connections?.[uuid].token !== 'string'
     ) {
       return;
     }
 
     const encodeValues = (object) => {
       if (typeof object === 'object' && object !== null) {
-        if ('type_url' in object && 'value' in object) {
-          // We have a type_url and value object at this same level, we'll treat this a trait requiring encoding
-          let TraitMap = this.#protobufRoot.lookup(object.type_url.split('/')[1]);
+        // We have a type_url and value object at this same level, we'll treat this a trait requiring encoding
+        if (typeof object.type_url === 'string' && object.value !== undefined) {
+          let typeName = object.type_url.split('/')[1];
+          let TraitMap = this.#protobufRoot.lookup(typeName);
           if (TraitMap !== null) {
             object.value = TraitMap.encode(TraitMap.fromObject(object.value)).finish();
           }
         }
 
-        for (let key in object) {
-          if (object?.[key] !== undefined) {
+        for (const key in object) {
+          if (object[key] !== undefined) {
             encodeValues(object[key]);
           }
         }
@@ -3174,28 +3080,27 @@ export default class NestAccfactory {
       encodeValues(values);
 
       let encodedData = TraitMapRequest.encode(TraitMapRequest.fromObject(values)).finish();
-      await fetchWrapper(
-        'post',
-        'https://' + this.#connections[connectionUUID].protobufAPIHost + '/nestlabs.gateway.v1.' + service + '/' + command,
-        {
-          headers: {
-            referer: 'https://' + this.#connections[connectionUUID].referer,
-            'User-Agent': USERAGENT,
-            Authorization: 'Basic ' + this.#connections[connectionUUID].token,
-            'Content-Type': 'application/x-protobuf',
-            'X-Accept-Content-Transfer-Encoding': 'binary',
-            'X-Accept-Response-Streaming': 'true',
+      try {
+        let response = await fetchWrapper(
+          'post',
+          'https://' + this.#connections[uuid].protobufAPIHost + '/nestlabs.gateway.v1.' + service + '/' + command,
+          {
+            headers: {
+              referer: 'https://' + this.#connections[uuid].referer,
+              'User-Agent': USERAGENT,
+              Authorization: 'Basic ' + this.#connections[uuid].token,
+              'Content-Type': 'application/x-protobuf',
+              'X-Accept-Content-Transfer-Encoding': 'binary',
+              'X-Accept-Response-Streaming': 'true',
+            },
           },
-        },
-        encodedData,
-      )
-        .then((response) => response.arrayBuffer())
-        .then((data) => {
-          commandResponse = TraitMapResponse.decode(Buffer.from(data)).toJSON();
-        })
-        .catch((error) => {
-          this?.log?.debug && this.log.debug('Protobuf gateway service command failed with error. Error was "%s"', error?.code);
-        });
+          encodedData,
+        );
+        let buffer = await response.arrayBuffer();
+        commandResponse = TraitMapResponse.decode(Buffer.from(buffer)).toJSON();
+      } catch (error) {
+        this?.log?.debug?.('Protobuf gateway service command failed with error. Error was "%s"', error?.code);
+      }
     }
     return commandResponse;
   }
@@ -3203,28 +3108,22 @@ export default class NestAccfactory {
 
 // General helper functions which don't need to be part of an object class
 function adjustTemperature(temperature, currentTemperatureUnit, targetTemperatureUnit, round) {
-  // Converts temperatures between C/F and vice-versa
-  // Also rounds temperatures to 0.5 increments for C and 1.0 for F
-  if (targetTemperatureUnit.toUpperCase() === 'C') {
-    if (currentTemperatureUnit.toUpperCase() === 'F') {
-      // convert from F to C
-      temperature = ((temperature - 32) * 5) / 9;
-    }
-    if (round === true) {
-      // round to nearest 0.5C
-      temperature = Math.round(temperature * 2) * 0.5;
-    }
-  }
+  currentTemperatureUnit = currentTemperatureUnit?.toUpperCase?.();
+  targetTemperatureUnit = targetTemperatureUnit?.toUpperCase?.();
 
-  if (targetTemperatureUnit.toUpperCase() === 'F') {
-    if (currentTemperatureUnit.toUpperCase() === 'C') {
-      // convert from C to F
-      temperature = (temperature * 9) / 5 + 32;
+  if (currentTemperatureUnit === 'F' && targetTemperatureUnit === 'C') {
+    temperature = ((temperature - 32) * 5) / 9;
+    if (round === true) {
+      temperature = Math.round(temperature * 2) / 2; // round to nearest 0.5°C
     }
+  } else if (currentTemperatureUnit === 'C' && targetTemperatureUnit === 'F') {
+    temperature = (temperature * 9) / 5 + 32;
     if (round === true) {
-      // round to nearest 1F
-      temperature = Math.round(temperature);
+      temperature = Math.round(temperature); // round to nearest 1°F
     }
+  } else if (round === true) {
+    // No conversion, just rounding
+    temperature = targetTemperatureUnit === 'C' ? Math.round(temperature * 2) / 2 : Math.round(temperature);
   }
 
   return temperature;
@@ -3234,12 +3133,14 @@ function makeHomeKitName(nameToMakeValid) {
   // Strip invalid characters to meet HomeKit naming requirements
   // Ensure only letters or numbers are at the beginning AND/OR end of string
   // Matches against uni-code characters
-  return typeof nameToMakeValid === 'string'
-    ? nameToMakeValid
-        .replace(/[^\p{L}\p{N}\p{Z}\u2019 '.,-]/gu, '')
-        .replace(/^[^\p{L}\p{N}]*/gu, '')
-        .replace(/[^\p{L}\p{N}]+$/gu, '')
-    : nameToMakeValid;
+  let validHomeKitName = nameToMakeValid;
+  if (typeof nameToMakeValid === 'string') {
+    validHomeKitName = nameToMakeValid
+      .replace(/[^\p{L}\p{N}\p{Z}\u2019 '.,-]/gu, '') // Remove disallowed characters
+      .replace(/^[^\p{L}\p{N}]*/gu, '') // Trim invalid prefix
+      .replace(/[^\p{L}\p{N}]+$/gu, ''); // Trim invalid suffix
+  }
+  return validHomeKitName;
 }
 
 function crc24(valueToHash) {
@@ -3266,65 +3167,127 @@ function crc24(valueToHash) {
     0x7c0401, 0x42fa2f, 0xc4b6d4, 0xc82f22, 0x4e63d9, 0xd11cce, 0x575035, 0x5bc9c3, 0xdd8538,
   ];
 
-  let crc24 = 0xb704ce; // init crc24 hash;
-  valueToHash = Buffer.from(valueToHash); // convert value into buffer for processing
-  for (let index = 0; index < valueToHash.length; index++) {
-    crc24 = (crc24HashTable[((crc24 >> 16) ^ valueToHash[index]) & 0xff] ^ (crc24 << 8)) & 0xffffff;
+  let crc = 0xb704ce;
+
+  const buffer = Buffer.from(valueToHash);
+
+  for (let i = 0; i < buffer.length; i++) {
+    const index = ((crc >> 16) ^ buffer[i]) & 0xff;
+    crc = (crc24HashTable[index] ^ (crc << 8)) & 0xffffff;
   }
-  return crc24.toString(16); // return crc24 as hex string
+
+  return crc.toString(16).padStart(6, '0'); // ensures 6-digit hex
 }
 
-function scaleValue(value, sourceRangeMin, sourceRangeMax, targetRangeMin, targetRangeMax) {
-  if (value < sourceRangeMin) {
-    value = sourceRangeMin;
+function scaleValue(value, sourceMin, sourceMax, targetMin, targetMax) {
+  if (sourceMax === sourceMin) {
+    return targetMin;
   }
-  if (value > sourceRangeMax) {
-    value = sourceRangeMax;
-  }
-  return ((value - sourceRangeMin) * (targetRangeMax - targetRangeMin)) / (sourceRangeMax - sourceRangeMin) + targetRangeMin;
+
+  value = Math.max(sourceMin, Math.min(sourceMax, value));
+
+  return ((value - sourceMin) * (targetMax - targetMin)) / (sourceMax - sourceMin) + targetMin;
 }
 
-async function fetchWrapper(method, url, options, data, response) {
+async function fetchWrapper(method, url, options, data) {
   if ((method !== 'get' && method !== 'post') || typeof url !== 'string' || url === '' || typeof options !== 'object') {
     return;
   }
 
-  if (isNaN(options?.timeout) === false && Number(options?.timeout) > 0) {
-    // If a timeout is specified in the options, setup here
+  if (isNaN(options?.timeout) === false && Number(options.timeout) > 0) {
     // eslint-disable-next-line no-undef
     options.signal = AbortSignal.timeout(Number(options.timeout));
   }
 
-  if (options?.retry === undefined) {
-    // If not retry option specifed , we'll do just once
+  if (isNaN(options.retry) === true || options.retry < 1) {
     options.retry = 1;
   }
 
-  options.method = method; // Set the HTTP method to use
+  if (isNaN(options._retryCount) === true) {
+    options._retryCount = 0;
+  }
+
+  options.method = method;
 
-  if (method === 'post' && typeof data !== undefined) {
-    // Doing a HTTP post, so include the data in the body
+  if (method === 'post' && data !== undefined) {
     options.body = data;
   }
 
-  if (options.retry > 0) {
+  let response;
+  try {
     // eslint-disable-next-line no-undef
     response = await fetch(url, options);
-    if (response.ok === false && options.retry > 1) {
-      options.retry--; // One less retry to go
-
-      // Try again after short delay (500ms)
-      // We pass back in this response also for when we reach zero retries and still not successful
-      await new Promise((resolve) => setTimeout(resolve, 500));
-      // eslint-disable-next-line no-undef
-      response = await fetchWrapper(method, url, options, data, structuredClone(response));
+  } catch (error) {
+    if (options.retry > 1) {
+      options.retry--;
+      options._retryCount++;
+
+      const delay = 500 * 2 ** (options._retryCount - 1);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+
+      return fetchWrapper(method, url, options, data);
     }
-    if (response.ok === false && options.retry === 0) {
-      let error = new Error(response.statusText);
-      error.code = response.status;
-      throw error;
+
+    error.message = `Fetch failed for ${method.toUpperCase()} ${url} after ${options._retryCount + 1} attempt(s): ${error.message}`;
+    throw error;
+  }
+
+  if (response?.ok === false) {
+    if (options.retry > 1) {
+      options.retry--;
+      options._retryCount++;
+
+      let delay = 500 * 2 ** (options._retryCount - 1);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+
+      return fetchWrapper(method, url, options, data);
     }
+
+    let error = new Error(`HTTP ${response.status} on ${method.toUpperCase()} ${url}: ${response.statusText || 'Unknown error'}`);
+    error.code = response.status;
+    throw error;
   }
 
   return response;
 }
+
+function parseDurationToSeconds(inputDuration, { defaultValue = null, min = 0, max = Infinity } = {}) {
+  let normalisedSeconds = defaultValue;
+
+  if (inputDuration !== undefined && inputDuration !== null && inputDuration !== '') {
+    inputDuration = String(inputDuration).trim().toLowerCase();
+
+    // Case: plain numeric seconds (e.g. "30")
+    if (/^\d+$/.test(inputDuration) === true) {
+      normalisedSeconds = Number(inputDuration);
+    } else {
+      // Process input into normalised units. We'll convert in standard h (hours), m (minutes), s (seconds)
+      inputDuration = inputDuration
+        .replace(/hrs?|hours?/g, 'h')
+        .replace(/mins?|minutes?/g, 'm')
+        .replace(/secs?|s\b/g, 's')
+        .replace(/ +/g, '');
+
+      // Match duration format like "1h30m15s"
+      let match = inputDuration.match(/^((\d+)h)?((\d+)m)?((\d+)s?)?$/);
+
+      if (Array.isArray(match) === true) {
+        let total = Number(match[2] || 0) * 3600 + Number(match[4] || 0) * 60 + Number(match[6] || 0);
+        normalisedSeconds = Math.floor(total / 3600) * 3600 + Math.floor((total % 3600) / 60) * 60 + (total % 60);
+      }
+    }
+
+    if (normalisedSeconds === null || isNaN(normalisedSeconds) === true) {
+      normalisedSeconds = defaultValue;
+    }
+
+    if (isNaN(min) === false && normalisedSeconds < min) {
+      normalisedSeconds = min;
+    }
+    if (isNaN(max) === false && normalisedSeconds > max) {
+      normalisedSeconds = max;
+    }
+  }
+
+  return normalisedSeconds;
+}