nodejs-poolcontroller 8.4.0 → 8.4.1

package/.github/workflows/ghcr-publish.yml

@@ -33,7 +33,7 @@ jobs:
             type=sha
             type=raw,value=latest,enable={{is_default_branch}}
           labels: |
-            org.opencontainers.image.source=${{ github.repository }}
+            org.opencontainers.image.source=https://github.com/${{ github.repository }}
             org.opencontainers.image.revision=${{ github.sha }}
             org.opencontainers.image.title=njspc
             org.opencontainers.image.description=Pentair pool controller bridge (GHCR image)

package/157_issues.md

@@ -0,0 +1,101 @@
+# IntelliCenter v3 Config Triage Summary
+
+## Initial issues reported
+
+- General -> Personal Information:
+  - City/State/Zip not syncing between dashPanel and WCP/OCP.
+  - Pool Alias/Owner/Zip values overwriting each other.
+  - Latitude blank in dashPanel; longitude not editable/syncing.
+- General -> Timezone & Locality:
+  - Switching Internet/12h <-> Manual/24h caused bogus Pool/Spa setpoints and heat mode in dashPanel.
+- General -> Delays:
+  - Delays not linking correctly.
+  - Missing v3 fields: Frz Cycle Time (min) and Frz Override (min).
+  - Manual Operation Priority in dashPanel does not clearly map to WCP.
+- Sensor Calibration:
+  - Generally working; occasional +/-1 variance (likely timing/read cadence).
+- Alerts/Security:
+  - Tabs empty.
+- Loading stuck at 0%:
+  - Intermittent post-change loading hang (notably replay 157).
+
+## What is fixed
+
+- v3 Action 168 body temp/settings parsing hardened:
+  - Added handling for payload variants so Pool/Spa setpoint/heat-mode values are parsed correctly.
+- Latitude/Longitude outbound mapping corrected:
+  - Fixed wrong latitude assignment target.
+  - Corrected byte math/order for lat/lon packet payload.
+  - Normalized coordinate assignment precision.
+- General config refresh reliability improved:
+  - Forced v3 refresh path to include general category refresh to reduce stale General-tab data.
+- Country field inbound parse width increased:
+  - Expanded from 16 to 32 bytes to avoid truncation/misalignment.
+
+## What is not fully fixed yet
+
+- Personal Information end-to-end mapping:
+  - Alias/Owner/City/State/Zip still need definitive byte-level inbound/outbound confirmation.
+- Delays v3 fields:
+  - Frz Cycle Time (min) and Frz Override (min) offsets not yet identified.
+  - Manual Operation Priority mapping still unconfirmed.
+- Alerts/Security mapping:
+  - Need packet-level evidence to confirm source actions/offsets and parser wiring.
+- Loading stuck:
+  - Root cause identified as RS-485 comm instability + frequent v3 refresh retriggers under noisy conditions; mitigation implementation still pending.
+
+## Root cause of loading stuck
+
+- In replay 157, poolState ends with:
+  - status.name = "loading"
+  - percent = 0
+- Same run shows elevated comm issues:
+  - unrecoverable collisions
+  - invalid packets
+  - outbound retries
+  - repeated config refresh triggers (ACK(168), ACK(184), piggyback)
+- Net effect:
+  - refresh cycles are retriggered/churned during unstable traffic and can fail to settle cleanly.
+
+## Information needed to finish remaining work
+
+- Capture one setting change at a time (with timestamp notes), then wait a few seconds before next change.
+
+### Personal Information
+
+- Pool Alias
+- Owner
+- City
+- State
+- Zip
+- Latitude
+- Longitude
+
+### Time/Locality
+
+- 12/24-hour switch
+- Internet/manual clock source
+- DST toggle
+- Time zone change
+
+### Delays (especially v3-specific)
+
+- Frz Cycle Time (min)
+- Frz Override (min)
+- Any setting suspected to map to Manual Operation Priority
+
+### Alerts/Security
+
+- Toggle each available option individually (if present on WCP/OCP)
+
+### Packet evidence needed for each run
+
+- Action 30 (config responses)
+- Action 168 (external/config broadcasts)
+- Related request/ack flow (Action 222, Action 1, piggyback trigger context)
+
+## Current status
+
+- DONE: High-confidence parsing and lat/lon write-path fixes applied.
+- PENDING: Remaining fields require targeted packet captures for accurate mapping.
+- PENDING: Loading-hang mitigation implementation.

package/AGENTS.md

@@ -123,6 +123,17 @@
 **Generalization:** This applies to *anything* that is overridden by controller boards (IntelliCenter, EasyTouch, IntelliTouch, AquaLink, SunTouch, Nixie, etc.).  
 If you find yourself writing `if (sys.controllerType === ...)` inside `SystemBoard.ts`, that is almost always a design smell—create/extend the controller-specific command class in the appropriate board file and keep `SystemBoard.ts` purely generic.
 
+### 7.1 Nixie Chemistry Relay UI Sync: Circuits, Not Features (CRITICAL)
+**Rule:** For Nixie/REM chemistry relay status sync, treat **circuits** as the hardware-bound source of truth. Do **not** implement hardware binding logic on `Feature`.
+
+- `Feature` is logical/virtual state in this context; relay bindings (`connectionId`, `deviceBinding`) belong on `Circuit`.
+- When chemistry pump state changes (`NixieChemPump.turnOn/turnOff`), locate matching entries in `sys.circuits` by `connectionId` + `deviceBinding`.
+- Reflect state in `state.circuits` (including `setEndTime` semantics) and emit changes; do not bind/sync through `state.features`.
+- Avoid duplicate relay writes: if the chemistry code already sent the hardware command, sync in-memory circuit state instead of issuing an additional toggle command for that same relay.
+- If the UI "Features" panel must show the relay, use a **circuit** with `showInFeatures=true` (presentation concern), not a bound `Feature`.
+
+**Context:** Added after investigation/fix for discussion #1159 (acid feeder relay dot not reflecting REM dosing state in dashPanel).
+
 ## Analysis Patterns
 
 ### 6. Examine Working State, Not Just Failures
@@ -458,6 +469,11 @@ Always prefix with `#` and packet ID.
 4. Look for request/response pairs (outbound `dir":"out"` → inbound `dir":"in"`)
 5. **Always extract and display packet IDs** in any analysis output
 
+**Replay caveat (API lines):**
+- Some replay packet logs include captured API requests (for example `/app/config/stopPacketCapture` in `v3.008_replay.157_config1` and `v3.008_replay.160_config2`).
+- Treat these as tooling/control-plane events, not protocol source-of-truth packets.
+- If replaying API lines out-of-order causes app errors, classify separately from RS-485 protocol regressions.
+
 **Decoding times (v3.004 big-endian):**
 - Two bytes `[hi, lo]` → `hi * 256 + lo` = minutes since midnight
 - Example: `[2, 33]` → `2*256 + 33 = 545` → 9:05 AM
@@ -592,6 +608,6 @@ Each protocol file should include:
 
 ---
 
-**Last Updated:** December 16, 2025  
+**Last Updated:** March 13, 2026  
 **Source:** nodejs-poolController IntelliCenter v3.004 compatibility work
 

package/README.md

@@ -100,6 +100,14 @@ Assuming you cloned the repo, the following are easy steps to get the latest ver
 
 See the [wiki](https://github.com/tagyoureit/nodejs-poolController/wiki/Docker). Thanks @wurmr @andylippitt @emes.
 
+#### Image channels (important)
+
+The project has multiple image channels. `latest` only means latest within that specific channel.
+
+* `ghcr.io/tagyoureit/njspc` - official controller image published from this repository's GitHub Actions (tracks upstream `master`).
+* `msmi/nodejs-poolcontroller` - legacy Docker Hub controller image (can lag upstream).
+* `ghcr.io/rstrouse/njspc-dash` - dashPanel image currently published separately.
+
 ### Docker Compose (Controller + Optional dashPanel UI)
 
 Below is an example `docker-compose.yml` snippet showing this controller (`njspc`) and an OPTIONAL dashPanel UI service (`njspc-dash`). The dashPanel image is published separately; uncomment if you want a built-in web dashboard on port 5150.
@@ -107,7 +115,7 @@ Below is an example `docker-compose.yml` snippet showing this controller (`njspc
 ```yaml
 services:
    njspc:
-      image: ghcr.io/sam2kb/njspc
+      image: ${NJSPC_IMAGE:-ghcr.io/tagyoureit/njspc}
       container_name: njspc
       restart: unless-stopped
       environment:
@@ -137,7 +145,7 @@ services:
       # user: "0:0"
 
    njspc-dash:
-     image: ghcr.io/sam2kb/njspc-dash
+     image: ${NJSPC_DASH_IMAGE:-ghcr.io/rstrouse/njspc-dash}
      container_name: njspc-dash
      restart: unless-stopped
      depends_on:
@@ -172,6 +180,9 @@ Quick start:
 
 Notes:
 * Provide either RS-485 device OR enable network (ScreenLogic) connection.
+* `latest` is channel-specific; use image labels to verify exact code revision:
+  * `docker image inspect ghcr.io/tagyoureit/njspc:latest --format '{{ index .Config.Labels "org.opencontainers.image.revision" }}'`
+  * `docker image inspect msmi/nodejs-poolcontroller:latest --format '{{ index .Config.Labels "git-commit" }}'`
 * Coordinates env vars prevent heliotrope warnings before the panel reports location.
 * Persistence (controller):
    * `./server-config.json:/app/config.json` main runtime config. You can either:

package/controller/Equipment.ts

@@ -59,6 +59,7 @@ interface IPoolSystem {
     remotes: RemoteCollection;
     eggTimers: EggTimerCollection;
     security: Security;
+    alerts: Alerts;
     chemControllers: ChemControllerCollection;
     board: SystemBoard;
     updateControllerDateTimeAsync(
@@ -202,6 +203,7 @@ export class PoolSystem implements IPoolSystem {
         this.lightGroups = new LightGroupCollection(this.data, 'lightGroups');
         this.remotes = new RemoteCollection(this.data, 'remotes');
         this.security = new Security(this.data, 'security');
+        this.alerts = new Alerts(this.data, 'alerts');
         this.customNames = new CustomNameCollection(this.data, 'customNames');
         this.eggTimers = new EggTimerCollection(this.data, 'eggTimers');
         this.chemControllers = new ChemControllerCollection(this.data, 'chemControllers');
@@ -322,6 +324,7 @@ export class PoolSystem implements IPoolSystem {
             this.remotes.clear(0);
             this.schedules.clear(0);
             this.security.clear();
+            this.alerts.clear();
             this.valves.clear(0);
             this.chemControllers.clear(0);
             this.filters.clear(0);
@@ -376,6 +379,7 @@ export class PoolSystem implements IPoolSystem {
     public lightGroups: LightGroupCollection;
     public remotes: RemoteCollection;
     public security: Security;
+    public alerts: Alerts;
     public customNames: CustomNameCollection;
     public chemControllers: ChemControllerCollection;
     public chemDosers: ChemDoserCollection;
@@ -479,6 +483,8 @@ export class PoolSystem implements IPoolSystem {
             remotes: self.data.remotes || [],
             heaters: self.data.heaters || [],
             covers: self.data.covers || [],
+            security: self.data.security || {},
+            alerts: self.data.alerts || {},
             appVersion: self.data.appVersion || '0.0.0'
         };
     }
@@ -835,6 +841,8 @@ export class Options extends EqItem {
         if (typeof this.data.heaterStartDelayTime === 'undefined') this.data.heaterStartDelayTime = 10;
         if (typeof this.data.cleanerStartDelayTime === 'undefined') this.data.cleanerStartDelayTime = 300; // 5min
         if (typeof this.data.cleanerSolarDelayTime === 'undefined') this.data.cleanerSolarDelayTime = 300; // 5min
+        if (typeof this.data.freezeCycleTime === 'undefined') this.data.freezeCycleTime = 15;
+        if (typeof this.data.freezeOverride === 'undefined') this.data.freezeOverride = 30;
     }
     public get clockMode(): number | any { return this.data.clockMode; }
     public set clockMode(val: number | any) { this.setDataVal('clockMode', sys.board.valueMaps.clockModes.encode(val)); }
@@ -857,6 +865,10 @@ export class Options extends EqItem {
     public set cooldownDelay(val: boolean) { this.setDataVal('cooldownDelay', val); }
     public get freezeThreshold(): number { return this.data.freezeThreshold; }
     public set freezeThreshold(val: number) { this.setDataVal('freezeThreshold', val); }
+    public get freezeCycleTime(): number { return this.data.freezeCycleTime; }
+    public set freezeCycleTime(val: number) { this.setDataVal('freezeCycleTime', val); }
+    public get freezeOverride(): number { return this.data.freezeOverride; }
+    public set freezeOverride(val: number) { this.setDataVal('freezeOverride', val); }
     public get heaterStartDelay(): boolean { return this.data.heaterStartDelay; }
     public set heaterStartDelay(val: boolean) { this.setDataVal('heaterStartDelay', val); }
     public get heaterStartDelayTime(): number { return this.data.heaterStartDelayTime; }
@@ -1453,6 +1465,7 @@ export interface ICircuit {
     freeze?: boolean;
     isActive: boolean;
     lightingTheme?: number;
+    level?: number;
     //showInCircuits?: boolean;
     showInFeatures?: boolean;
     macro?: boolean;
@@ -2173,13 +2186,46 @@ export class SecurityRole extends EqItem {
     public set flag2(val: number) { this.setDataVal('flag2', val); }
     public get pin(): string { return this.data.pin; }
     public set pin(val: string) { this.setDataVal('pin', val); }
+    public get permissionsMask(): number { return this.data.permissionsMask; }
+    public set permissionsMask(val: number) { this.setDataVal('permissionsMask', val); }
+    public get permissionsBytes(): number[] { return Array.isArray(this.data.permissionsBytes) ? this.data.permissionsBytes : []; }
+    public set permissionsBytes(val: number[]) { this.setDataVal('permissionsBytes', Array.isArray(val) ? [...val] : []); }
 }
 export class Security extends EqItem {
     public dataName = 'securityConfig';
+    public initData() {
+        if (typeof this.data.enabled === 'undefined') this.data.enabled = false;
+        if (typeof this.data.enabledByte === 'undefined') this.data.enabledByte = 0;
+    }
     public get enabled(): boolean { return this.data.enabled; }
     public set enabled(val: boolean) { this.setDataVal('enabled', val); }
+    public get enabledByte(): number { return this.data.enabledByte; }
+    public set enabledByte(val: number) { this.setDataVal('enabledByte', val); }
     public get roles(): SecurityRoleCollection { return new SecurityRoleCollection(this.data, "roles"); }
 }
+export class Alerts extends EqItem {
+    public dataName = 'alertsConfig';
+    public initData() {
+        if (typeof this.data.circuitNotifications === 'undefined') this.data.circuitNotifications = 0;
+        if (typeof this.data.pumpNotifications === 'undefined') this.data.pumpNotifications = 0;
+        if (typeof this.data.heaterNotifications === 'undefined') this.data.heaterNotifications = 0;
+        if (typeof this.data.chlorinatorNotifications === 'undefined') this.data.chlorinatorNotifications = 0;
+        if (typeof this.data.raw !== 'object' || this.data.raw === null) this.data.raw = {};
+    }
+    public get circuitNotifications(): number { return this.data.circuitNotifications; }
+    public set circuitNotifications(val: number) { this.setDataVal('circuitNotifications', val); }
+    public get pumpNotifications(): number { return this.data.pumpNotifications; }
+    public set pumpNotifications(val: number) { this.setDataVal('pumpNotifications', val); }
+    public get heaterNotifications(): number { return this.data.heaterNotifications; }
+    public set heaterNotifications(val: number) { this.setDataVal('heaterNotifications', val); }
+    public get chlorinatorNotifications(): number { return this.data.chlorinatorNotifications; }
+    public set chlorinatorNotifications(val: number) { this.setDataVal('chlorinatorNotifications', val); }
+    public setRaw(selector: number, raw: number[]) {
+        if (typeof this.data.raw !== 'object' || this.data.raw === null) this.data.raw = {};
+        this.data.raw[`selector${selector}`] = Array.isArray(raw) ? [...raw] : [];
+        this.hasChanged = true;
+    }
+}
 export class ChemControllerCollection extends EqItemCollection<ChemController> {
     constructor(data: any, name?: string) { super(data, name || "chemControllers"); }
     public createItem(data: any): ChemController { return new ChemController(data); }
@@ -2238,6 +2284,7 @@ export class ChemController extends EqItem implements IChemController {
         if (typeof this.data.lsiRange === 'undefined') this.data.lsiRange = { low: -.5, high: .5, enabled: true };
         if (typeof this.data.borates === 'undefined') this.data.borates = 0;
         if (typeof this.data.siCalcType === 'undefined') this.data.siCalcType = 0;
+        if (typeof this.data.intellichemStandalone === 'undefined') this.data.intellichemStandalone = false;
         super.initData();
     }
     public dataName = 'chemControllerConfig';
@@ -2253,6 +2300,8 @@ export class ChemController extends EqItem implements IChemController {
     public set address(val: number) { this.setDataVal('address', val); }
     public get isActive(): boolean { return this.data.isActive; }
     public set isActive(val: boolean) { this.setDataVal('isActive', val); }
+    public get intellichemStandalone(): boolean { return utils.makeBool(this.data.intellichemStandalone); }
+    public set intellichemStandalone(val: boolean) { this.setDataVal('intellichemStandalone', val); }
     public get calciumHardness(): number { return this.data.calciumHardness; }
     public set calciumHardness(val: number) { this.setDataVal('calciumHardness', val); }
     public get cyanuricAcid(): number { return this.data.cyanuricAcid; }

package/controller/State.ts

@@ -542,6 +542,8 @@ export interface ICircuitState {
     get(bCopy?: boolean);
     showInFeatures?: boolean;
     isActive?: boolean;
+    level?: number;
+    color?: { red: number; green: number; blue: number };
     startDelay?: boolean;
     stopDelay?: boolean;
     manualPriorityActive?: boolean;
@@ -1090,6 +1092,7 @@ export class PumpState extends EqState {
                 case 'vssvrs':
                 case 'vs':
                 case 'regalmodbus':
+                case 'neptunemodbus':
                     c.units = sys.board.valueMaps.pumpUnits.transformByName('rpm');
                     break;
                 case 'ss':
@@ -2073,6 +2076,11 @@ export class CircuitState extends EqState implements ICircuitState {
     }
     public get level(): number { return this.data.level; }
     public set level(val: number) { this.setDataVal('level', val); }
+    public get color(): { red: number; green: number; blue: number } { return this.data.color; }
+    public set color(val: { red: number; green: number; blue: number }) {
+        if (typeof val === 'undefined' || val === null) this.setDataVal('color', undefined);
+        else this.setDataVal('color', { red: val.red, green: val.green, blue: val.blue });
+    }
     public get commStatus(): number { return this.data.commStatus; }
     public set commStatus(val: number) {
         if (this.commStatus !== val) {

package/controller/boards/AquaLinkBoard.ts

@@ -26,6 +26,16 @@ import { conn } from '../comms/Comms';
 import { ncp } from "../nixie/Nixie";
 import { utils } from '../Constants';
 
+const IAQUALINK_SENDCMD_DEST = 0x00;
+const IAQUALINK_SENDCMD_SOURCE = 0x24;
+const IAQUALINK_SENDCMD_ACTION = 0x73;
+const IAQUALINK_SENDCMD_PREFIX = 0x01;
+const IAQUALINK_SENDCMD_PAYLOAD_LEN = 12;
+const IAQUALINK_OPCODE_THEME = 0x61;
+const IAQUALINK_OPCODE_RGB = 0x63;
+const IAQUALINK_OPCODE_SYNC = 0x65;
+const IAQUALINK_WATERCOLORS_CIRCUIT_TYPE = 18;
+
 export class AquaLinkBoard extends SystemBoard {
     constructor(system: PoolSystem) {
         super(system);
@@ -41,6 +51,32 @@ export class AquaLinkBoard extends SystemBoard {
             [32, { name: 'IT5X', part: 'i5X', desc: 'IntelliTouch i5X', circuits: 5 }],
             [33, { name: 'IT10X', part: 'i10X', desc: 'IntelliTouch i10X', circuits: 10 }]
         ]);
+        this.valueMaps.circuitFunctions.merge([
+            [IAQUALINK_WATERCOLORS_CIRCUIT_TYPE, {
+                name: 'watercolors',
+                desc: 'Infinite WaterColors',
+                isLight: true,
+                theme: 'watercolors',
+                supportsBrightness: true,
+                supportsCustomColor: true
+            }]
+        ]);
+        this.valueMaps.lightThemes.merge([
+            [56, { name: 'alpinewhite', desc: 'Alpine White', types: ['watercolors'], sequence: 1 }],
+            [57, { name: 'skyblue', desc: 'Sky Blue', types: ['watercolors'], sequence: 2 }],
+            [58, { name: 'cobaltblue', desc: 'Cobalt Blue', types: ['watercolors'], sequence: 3 }],
+            [59, { name: 'caribbeanblue', desc: 'Caribbean Blue', types: ['watercolors'], sequence: 4 }],
+            [60, { name: 'springgreen', desc: 'Spring Green', types: ['watercolors'], sequence: 5 }],
+            [61, { name: 'emeraldgreen', desc: 'Emerald Green', types: ['watercolors'], sequence: 6 }],
+            [62, { name: 'emeraldrose', desc: 'Emerald Rose', types: ['watercolors'], sequence: 7 }],
+            [63, { name: 'magenta', desc: 'Magenta', types: ['watercolors'], sequence: 8 }],
+            [64, { name: 'violet', desc: 'Violet', types: ['watercolors'], sequence: 9 }],
+            [65, { name: 'slowcolorsplash', desc: 'Slow Color Splash', types: ['watercolors'], sequence: 10 }],
+            [66, { name: 'fastcolorsplash', desc: 'Fast Color Splash', types: ['watercolors'], sequence: 11 }],
+            [67, { name: 'americathebeautiful', desc: 'America Beautiful', types: ['watercolors'], sequence: 12 }],
+            [68, { name: 'fattuesday', desc: 'Fat Tuesday', types: ['watercolors'], sequence: 13 }],
+            [69, { name: 'discotech', desc: 'Disco Tech', types: ['watercolors'], sequence: 14 }]
+        ]);
     }
     public initExpansionModules(byte1: number, byte2: number) {
         console.log(`Jandy AquaLink System Detected!`);
@@ -401,6 +437,59 @@ class AquaLinkBodyCommands extends BodyCommands {
     }
 }
 class AquaLinkCircuitCommands extends CircuitCommands {
+    private isWaterColorsCircuit(circuit: ICircuit): boolean {
+        const type = sys.board.valueMaps.circuitFunctions.transform(circuit.type);
+        return typeof type !== 'undefined' && type.isLight === true && type.theme === 'watercolors';
+    }
+    private getWaterColorsTheme(theme: number | any) {
+        const thm = sys.board.valueMaps.lightThemes.findItem(theme);
+        if (typeof thm === 'undefined' || !Array.isArray(thm.types) || !thm.types.includes('watercolors')) {
+            throw new InvalidOperationError(`Theme ${theme} is not valid for Infinite WaterColors`, 'setLightThemeAsync');
+        }
+        return thm;
+    }
+    private normalizeWaterColorsBrightness(level: number): number {
+        const parsed = parseInt(level as any, 10);
+        if (isNaN(parsed) || parsed < 0 || parsed > 100) {
+            throw new InvalidEquipmentDataError(`Invalid WaterColors brightness ${level}`, 'Circuit', level);
+        }
+        return parsed;
+    }
+    private normalizeWaterColorsComponent(value: number, component: string): number {
+        const parsed = parseInt(value as any, 10);
+        if (isNaN(parsed) || parsed < 0 || parsed > 255) {
+            throw new InvalidEquipmentDataError(`Invalid WaterColors ${component} component ${value}`, 'Circuit', value);
+        }
+        return parsed;
+    }
+    private async sendIAquaLinkLightCommandAsync(opcode: number, payload: number[], scope: string): Promise<void> {
+        const cmdPayload = payload.slice(0, IAQUALINK_SENDCMD_PAYLOAD_LEN);
+        while (cmdPayload.length < IAQUALINK_SENDCMD_PAYLOAD_LEN) cmdPayload.push(0);
+        await Outbound.create({
+            protocol: Protocol.AquaLink,
+            dest: IAQUALINK_SENDCMD_DEST,
+            source: IAQUALINK_SENDCMD_SOURCE,
+            action: IAQUALINK_SENDCMD_ACTION,
+            payload: [IAQUALINK_SENDCMD_PREFIX, opcode, ...cmdPayload],
+            retries: 2,
+            scope
+        }).sendAsync();
+    }
+    private async sendWaterColorsOnCommandAsync(id: number): Promise<void> {
+        await this.sendIAquaLinkLightCommandAsync(IAQUALINK_OPCODE_SYNC, [0x01, 0x00], `aqualink-watercolors-on-${id}`);
+    }
+    private async sendWaterColorsOffCommandAsync(id: number): Promise<void> {
+        await this.sendIAquaLinkLightCommandAsync(IAQUALINK_OPCODE_THEME, [0x00, 0xFF, 0x00], `aqualink-watercolors-off-${id}`);
+    }
+    private setWaterColorsState(circuit: ICircuit, cstate: any, isOn: boolean): void {
+        sys.board.circuits.setEndTime(circuit, cstate, isOn);
+        cstate.isOn = isOn;
+    }
+    private getWaterColorsLevel(circuit: ICircuit, cstate: any): number {
+        if (typeof circuit.level !== 'undefined' && circuit.level > 0) return circuit.level;
+        if (typeof cstate.level !== 'undefined' && cstate.level > 0) return cstate.level;
+        return 100;
+    }
     public async setCircuitAsync(data: any): Promise<ICircuit> {
         try {
             let id = parseInt(data.id, 10);
@@ -413,6 +502,7 @@ class AquaLinkCircuitCommands extends CircuitCommands {
                 return circ;
             }
             let typeByte = parseInt(data.type, 10) || circuit.type || sys.board.valueMaps.circuitFunctions.getValue('generic');
+            this.assertSinglePoolSpaType(id, typeByte);
             let nameByte = 3; // set default `Aux 1`
             if (typeof data.nameId !== 'undefined') nameByte = data.nameId;
             else if (typeof circuit.name !== 'undefined') nameByte = circuit.nameId;
@@ -445,6 +535,19 @@ class AquaLinkCircuitCommands extends CircuitCommands {
         if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError('Circuit or Feature id not valid', id, 'Circuit'));
         let c = sys.circuits.getInterfaceById(id);
         if (c.master !== 0) return await super.setCircuitStateAsync(id, val);
+        if (this.isWaterColorsCircuit(c)) {
+            const cstate = state.circuits.getInterfaceById(id);
+            if (val) await this.sendWaterColorsOnCommandAsync(id);
+            else await this.sendWaterColorsOffCommandAsync(id);
+            this.setWaterColorsState(c, cstate, val);
+            if (val) {
+                const level = this.getWaterColorsLevel(c, cstate);
+                c.level = level;
+                cstate.level = level;
+            }
+            state.emitEquipmentChanges();
+            return cstate;
+        }
         if (id === 192 || c.type === 3) return await sys.board.circuits.setLightGroupThemeAsync(id - 191, val ? 1 : 0);
         if (id >= 192) return await sys.board.circuits.setCircuitGroupStateAsync(id, val);
 
@@ -507,8 +610,77 @@ class AquaLinkCircuitCommands extends CircuitCommands {
         });
     }
     public async setLightThemeAsync(id: number, theme: number): Promise<ICircuitState> {
-        // Re-route this as we cannot set individual circuit themes in *Touch.
-        return this.setLightGroupThemeAsync(id, theme);
+        const circ = sys.circuits.getItemById(id);
+        if (!this.isWaterColorsCircuit(circ)) {
+            // Re-route this as we cannot set individual circuit themes in *Touch.
+            return this.setLightGroupThemeAsync(id, theme);
+        }
+        const cstate = state.circuits.getItemById(id);
+        const thm = this.getWaterColorsTheme(theme);
+        const nop = sys.board.valueMaps.circuitActions.getValue('lighttheme');
+        cstate.action = nop;
+        cstate.emitEquipmentChange();
+        try {
+            if (!cstate.isOn) await this.sendWaterColorsOnCommandAsync(id);
+            await this.sendIAquaLinkLightCommandAsync(IAQUALINK_OPCODE_THEME, [0x00, thm.sequence, 0x64], `aqualink-watercolors-theme-${id}`);
+            this.setWaterColorsState(circ, cstate, true);
+            const level = this.getWaterColorsLevel(circ, cstate);
+            circ.level = level;
+            cstate.level = level;
+            circ.lightingTheme = thm.val;
+            cstate.lightingTheme = thm.val;
+            cstate.color = undefined;
+            state.emitEquipmentChanges();
+            return cstate;
+        }
+        catch (err) { return Promise.reject(new InvalidOperationError(err.message, 'setLightThemeAsync')); }
+        finally { cstate.action = 0; cstate.emitEquipmentChange(); }
+    }
+    public async setDimmerLevelAsync(id: number, level: number): Promise<ICircuitState> {
+        const circ = sys.circuits.getItemById(id);
+        if (!this.isWaterColorsCircuit(circ)) return super.setDimmerLevelAsync(id, level);
+        const cstate = state.circuits.getItemById(id);
+        const brightness = this.normalizeWaterColorsBrightness(level);
+        const nop = sys.board.valueMaps.circuitActions.getValue('lighttheme');
+        cstate.action = nop;
+        cstate.emitEquipmentChange();
+        try {
+            if (brightness > 0 && !cstate.isOn) await this.sendWaterColorsOnCommandAsync(id);
+            await this.sendIAquaLinkLightCommandAsync(IAQUALINK_OPCODE_THEME, [0x00, 0xFF, brightness], `aqualink-watercolors-brightness-${id}`);
+            circ.level = brightness;
+            cstate.level = brightness;
+            this.setWaterColorsState(circ, cstate, brightness > 0);
+            state.emitEquipmentChanges();
+            return cstate;
+        }
+        catch (err) { return Promise.reject(new InvalidOperationError(err.message, 'setDimmerLevelAsync')); }
+        finally { cstate.action = 0; cstate.emitEquipmentChange(); }
+    }
+    public async setLightColorAsync(id: number, color: { red: number; green: number; blue: number }): Promise<ICircuitState> {
+        const circ = sys.circuits.getItemById(id);
+        if (!this.isWaterColorsCircuit(circ)) return super.setLightColorAsync(id, color);
+        const cstate = state.circuits.getItemById(id);
+        const red = this.normalizeWaterColorsComponent(color.red, 'red');
+        const green = this.normalizeWaterColorsComponent(color.green, 'green');
+        const blue = this.normalizeWaterColorsComponent(color.blue, 'blue');
+        const nop = sys.board.valueMaps.circuitActions.getValue('lighttheme');
+        cstate.action = nop;
+        cstate.emitEquipmentChange();
+        try {
+            if (!cstate.isOn) await this.sendWaterColorsOnCommandAsync(id);
+            await this.sendIAquaLinkLightCommandAsync(IAQUALINK_OPCODE_RGB, [0x00, red, green, blue, 0x00], `aqualink-watercolors-rgb-${id}`);
+            const level = this.getWaterColorsLevel(circ, cstate);
+            circ.level = level;
+            cstate.level = level;
+            this.setWaterColorsState(circ, cstate, true);
+            circ.lightingTheme = sys.board.valueMaps.lightThemes.getValue('none');
+            cstate.lightingTheme = sys.board.valueMaps.lightThemes.getValue('none');
+            cstate.color = { red, green, blue };
+            state.emitEquipmentChanges();
+            return cstate;
+        }
+        catch (err) { return Promise.reject(new InvalidOperationError(err.message, 'setLightColorAsync')); }
+        finally { cstate.action = 0; cstate.emitEquipmentChange(); }
     }
     public async runLightGroupCommandAsync(obj: any): Promise<ICircuitState> {
         // Do all our validation.

package/controller/boards/EasyTouchBoard.ts

@@ -1218,6 +1218,26 @@ class TouchSystemCommands extends SystemCommands {
     }
 }
 class TouchBodyCommands extends BodyCommands {
+    public getHeatSources(bodyId: number) {
+        let heatSources = super.getHeatSources(bodyId);
+        for (let i = 0; i < heatSources.length; i++) {
+            let hm = heatSources[i];
+            if (hm?.name === 'ultratemp' && typeof hm.val === 'undefined') {
+                heatSources[i] = this.board.valueMaps.heatSources.transformByName('heatpump');
+            }
+        }
+        return heatSources;
+    }
+    public getHeatModes(bodyId: number) {
+        let heatModes = super.getHeatModes(bodyId);
+        for (let i = 0; i < heatModes.length; i++) {
+            let hm = heatModes[i];
+            if (hm?.name === 'ultratemp' && typeof hm.val === 'undefined') {
+                heatModes[i] = this.board.valueMaps.heatModes.transformByName('heatpump');
+            }
+        }
+        return heatModes;
+    }
     public async setBodyAsync(obj: any): Promise<Body> {
         // The 168 is a funky packet in *Touch because it can set:
         // * Intellichem Installed (byte 3, bit 1)
@@ -1499,6 +1519,7 @@ export class TouchCircuitCommands extends CircuitCommands {
             let cstate = state.circuits.getInterfaceById(data.id, true);
             let showInFeatures = cstate.showInFeatures = typeof data.showInFeatures !== 'undefined' ? utils.makeBool(data.showInFeatures) : circuit.showInFeatures;
             let typeByte = parseInt(data.type, 10) === 0 ? 0 : parseInt(data.type, 10) || circuit.type || sys.board.valueMaps.circuitFunctions.getValue('generic');
+            this.assertSinglePoolSpaType(id, typeByte);
             let freeze = typeof data.freeze !== 'undefined' ? utils.makeBool(data.freeze) : circuit.freeze;
             let nameByte = 3; // set default `Aux 1`
             if (typeof data.nameId !== 'undefined') nameByte = data.nameId;
@@ -2701,6 +2722,18 @@ class TouchHeaterCommands extends HeaterCommands {
         let heaters = sys.heaters.get();
         let types = sys.board.valueMaps.heaterTypes.toArray();
         let inst = { total: 0 };
+        // If NCP directly controls an ultratemp/heatpump for the same body, suppress
+        // corresponding OCP ghost entries for that body only.
+        let hasNcpUltratempForBody = (ocpHeater: Heater): boolean => {
+            let ocpBody = typeof ocpHeater.body === 'number' ? ocpHeater.body : 32;
+            return heaters.some(h => {
+                if (h.master !== 1 || h.isActive === false) return false;
+                let t = types.find(elem => elem.val === h.type);
+                if (!t || (t.name !== 'ultratemp' && t.name !== 'heatpump')) return false;
+                let ncpBody = typeof h.body === 'number' ? h.body : 32;
+                return ncpBody === 32 || ocpBody === 32 || ncpBody === ocpBody;
+            });
+        };
         for (let i = 0; i < types.length; i++) if (types[i].name !== 'none') inst[types[i].name] = 0;
         for (let i = 0; i < heaters.length; i++) {
             let heater = heaters[i];
@@ -2709,6 +2742,9 @@ class TouchHeaterCommands extends HeaterCommands {
             }
             let type = types.find(elem => elem.val === heater.type);
             if (typeof type !== 'undefined') {
+                // Skip OCP ghost heaters only when there is a matching NCP-controlled
+                // ultratemp/heatpump for this heater's body.
+                if (heater.master === 0 && (type.name === 'hybrid' || type.name === 'ultratemp' || type.name === 'solar') && hasNcpUltratempForBody(heater)) continue;
                 if (inst[type.name] === 'undefined') inst[type.name] = 0;
                 inst[type.name] = inst[type.name] + 1;
                 if (heater.coolingEnabled === true && type.hasCoolSetpoint === true) inst['hasCoolSetpoint'] = true;
@@ -2971,6 +3007,10 @@ class TouchHeaterCommands extends HeaterCommands {
                     [21, { name: 'ultratemp', desc: 'Ultratemp Only', hasCoolSetpoint: htypes.hasCoolSetpoint }]
                 ])
             }
+            else if (ultratempInstalled) {
+                sys.board.valueMaps.heatModes.set(1, { name: 'heatpump', desc: 'Heat Pump' });
+                sys.board.valueMaps.heatSources.set(2, { name: 'heatpump', desc: 'Heat Pump', hasCoolSetpoint: htypes.hasCoolSetpoint });
+            }
             else {
                 // only gas
                 sys.board.valueMaps.heatModes.delete(2);
@@ -3022,6 +3062,9 @@ class TouchChemControllerCommands extends ChemControllerCommands {
             let cyanuricAcid = typeof data.cyanuricAcid !== 'undefined' ? parseInt(data.cyanuricAcid, 10) : chem.cyanuricAcid;
             let alkalinity = typeof data.alkalinity !== 'undefined' ? parseInt(data.alkalinity, 10) : chem.alkalinity;
             let borates = typeof data.borates !== 'undefined' ? parseInt(data.borates, 10) : chem.borates || 0;
+            let intellichemStandalone = sys.controllerType === ControllerType.Nixie
+                ? (typeof data.intellichemStandalone !== 'undefined' ? utils.makeBool(data.intellichemStandalone) : chem.intellichemStandalone)
+                : false;
             let body = sys.board.bodies.mapBodyAssociation(typeof data.body === 'undefined' ? chem.body : data.body);
             if (typeof body === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Invalid body assignment`, 'chemController', data.body || chem.body));
             // Do a final validation pass so we dont send this off in a mess.
@@ -3107,6 +3150,7 @@ class TouchChemControllerCommands extends ChemControllerCommands {
             chem.alkalinity = alkalinity;
             chem.borates = borates;
             chem.body = schem.body = body.val;
+            chem.intellichemStandalone = intellichemStandalone;
             schem.isActive = chem.isActive = true;
             chem.lsiRange.enabled = lsiRange.enabled;
             chem.lsiRange.low = lsiRange.low;