feat(creator5): per-tool temps, nozzle count, firmware-format fix

The Creator 5 reports temperatures per-tool and a real nozzle count, but
the client was treating it like a single-nozzle printer. All three fixes
below are confirmed against both the C5 firmware and the FlashForge
slicer's network library (FlashNetwork.dll), so nothing here is a guess.

- TempControl can now set individual tool temps on the C5 tool-changer
  via the nozzles[] array - setToolTemp, setToolTemps and cancelToolTemp.
  The firmware only accepts the array when it has exactly four entries, so
  we always send four and use -200 to leave the untouched tools alone. The
  scalar path (setExtruderTemp) still drives rightNozzle as before.
- Expose NozzleCount from detail.nozzleCnt, so the C5 reads as 4 nozzles
  instead of 1.
- isNewFirmwareVersion no longer trips on the C5's 1.9.2 version string;
  the AD5X and Creator 5 always use the new payload format regardless of
  their firmware numbering.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: GhostTypes

src/api/controls/JobControl.test.ts

@@ -175,6 +175,42 @@ describe('JobControl', () => {
       );
     });
 
+    it('should use new firmware format for Creator 5 despite a low version string', async () => {
+      // The C5 reports a 1.x version that the numeric 3.1.3 check would read as
+      // "old"; the model flag must override that so material-station fields are sent.
+      (mockFiveMClient as { isCreator5: boolean }).isCreator5 = true;
+      mockFiveMClient.firmVer = '1.9.2';
+
+      mockedAxios.post.mockResolvedValue({
+        status: 200,
+        data: { code: 0, message: 'Success' },
+      });
+
+      const result = await jobControl.printLocalFile('test.gcode', true);
+
+      expect(result).toBe(true);
+      const body = mockedAxios.post.mock.calls[0][1] as Record<string, unknown>;
+      expect(body).toHaveProperty('useMatlStation', false);
+      expect(body).toHaveProperty('gcodeToolCnt', 0);
+      expect(body).toHaveProperty('materialMappings');
+    });
+
+    it('should use new firmware format for AD5X despite a low version string', async () => {
+      mockFiveMClient.isAD5X = true;
+      mockFiveMClient.firmVer = '1.1.7';
+
+      mockedAxios.post.mockResolvedValue({
+        status: 200,
+        data: { code: 0, message: 'Success' },
+      });
+
+      const result = await jobControl.printLocalFile('test.gcode', true);
+
+      expect(result).toBe(true);
+      const body = mockedAxios.post.mock.calls[0][1] as Record<string, unknown>;
+      expect(body).toHaveProperty('useMatlStation', false);
+    });
+
     it('should return false for non-200 status', async () => {
       mockedAxios.post.mockResolvedValue({
         status: 500,

src/api/controls/JobControl.ts

@@ -71,6 +71,14 @@ export class JobControl {
    * @private
    */
   private isNewFirmwareVersion(): boolean {
+    // The 3.1.3 threshold only applies to the 5M family. The AD5X and Creator 5
+    // series always use the new payload/header format, and their firmware
+    // versioning isn't comparable to the 5M's 3.x line (e.g. the C5 reports
+    // 1.9.2, which the numeric check below would wrongly read as "old"), so
+    // short-circuit to the new format for them.
+    if (this.client.isAD5X || this.client.isCreator5 || this.client.isCreator5Pro) {
+      return true;
+    }
     try {
       const currentVersion = this.client.firmVer.split('.');
       const minVersion = [3, 1, 3];

src/api/controls/TempControl.test.ts

@@ -224,5 +224,47 @@ describe('TempControl', () => {
 
       expect(mockTcpClient.gCode).not.toHaveBeenCalled();
     });
+
+    it('setToolTemp sets one tool and leaves the others at -200', async () => {
+      const result = await httpTempControl.setToolTemp(2, 230);
+
+      expect(result).toBe(true);
+      expect(mockSendControlCommand).toHaveBeenCalledWith(
+        'temperatureCtl_cmd',
+        expect.objectContaining({ nozzles: [-200, -200, 230, -200] })
+      );
+    });
+
+    it('setToolTemps sends all four per-tool targets', async () => {
+      await httpTempControl.setToolTemps([200, 210, 220, 230]);
+
+      expect(mockSendControlCommand).toHaveBeenCalledWith(
+        'temperatureCtl_cmd',
+        expect.objectContaining({ nozzles: [200, 210, 220, 230] })
+      );
+    });
+
+    it('cancelToolTemp turns a single tool off (-100)', async () => {
+      await httpTempControl.cancelToolTemp(0);
+
+      expect(mockSendControlCommand).toHaveBeenCalledWith(
+        'temperatureCtl_cmd',
+        expect.objectContaining({ nozzles: [-100, -200, -200, -200] })
+      );
+    });
+
+    it('setToolTemp rejects an out-of-range index without sending', async () => {
+      const result = await httpTempControl.setToolTemp(5, 200);
+
+      expect(result).toBe(false);
+      expect(mockSendControlCommand).not.toHaveBeenCalled();
+    });
+
+    it('setToolTemps rejects a wrong-length array without sending', async () => {
+      const result = await httpTempControl.setToolTemps([200, 210]);
+
+      expect(result).toBe(false);
+      expect(mockSendControlCommand).not.toHaveBeenCalled();
+    });
   });
 });

src/api/controls/TempControl.ts

@@ -16,6 +16,12 @@ import { Commands } from '../server/Commands';
 const TEMP_NO_CHANGE = -200;
 /** `temperatureCtl_cmd` value that turns a heater off. */
 const TEMP_OFF = -100;
+/**
+ * Number of tool/nozzle entries the Creator 5 firmware requires in the
+ * `nozzles` array. The firmware ignores the array unless its length is exactly
+ * this (confirmed via Ghidra: `size() == 4` check in the temp parser).
+ */
+const NOZZLE_COUNT = 4;
 
 /**
  * Provides methods for controlling the temperatures of various components of the FlashForge 3D printer,
@@ -46,13 +52,83 @@ export class TempControl {
     leftNozzle?: number;
     platform?: number;
     chamber?: number;
+    nozzles?: number[];
   }): Promise<boolean> {
-    return await this.client.control.sendControlCommand(Commands.TempControlCmd, {
+    const payload: {
+      rightNozzle: number;
+      leftNozzle: number;
+      platform: number;
+      chamber: number;
+      nozzles?: number[];
+    } = {
       rightNozzle: args.rightNozzle ?? TEMP_NO_CHANGE,
       leftNozzle: args.leftNozzle ?? TEMP_NO_CHANGE,
       platform: args.platform ?? TEMP_NO_CHANGE,
       chamber: args.chamber ?? TEMP_NO_CHANGE,
-    });
+    };
+    // Per-tool targets for Creator 5 tool-changers. Only included when supplied so
+    // the firmware's `size() == 4` check doesn't reject a partial/absent array.
+    if (args.nozzles !== undefined) {
+      payload.nozzles = args.nozzles;
+    }
+    return await this.client.control.sendControlCommand(Commands.TempControlCmd, payload);
+  }
+
+  /**
+   * Builds a {@link NOZZLE_COUNT}-length `nozzles` array of {@link TEMP_NO_CHANGE}
+   * placeholders with a single tool set to `value`.
+   * @returns The array, or null if `toolIndex` is out of range.
+   */
+  private buildNozzleArray(toolIndex: number, value: number): number[] | null {
+    if (!Number.isInteger(toolIndex) || toolIndex < 0 || toolIndex >= NOZZLE_COUNT) {
+      console.error(`TempControl: toolIndex ${toolIndex} out of range (0-${NOZZLE_COUNT - 1}).`);
+      return null;
+    }
+    const nozzles = new Array<number>(NOZZLE_COUNT).fill(TEMP_NO_CHANGE);
+    nozzles[toolIndex] = value;
+    return nozzles;
+  }
+
+  /**
+   * Sets the target temperature for a single tool/nozzle on a Creator 5 series
+   * tool-changer, leaving the other tools unchanged. Sent as a `nozzles` array
+   * (Creator 5 / 5 Pro, HTTP-only); see {@link setToolTemps} to set all at once.
+   * @param toolIndex Zero-based tool index (0-3 for T0-T3).
+   * @param temp Target temperature in Celsius.
+   * @returns A Promise resolving to true if the command is acknowledged.
+   */
+  public async setToolTemp(toolIndex: number, temp: number): Promise<boolean> {
+    const nozzles = this.buildNozzleArray(toolIndex, temp);
+    if (nozzles === null) return false;
+    return await this.sendHttpTempCommand({ nozzles });
+  }
+
+  /**
+   * Sets the target temperatures for all tools/nozzles on a Creator 5 series
+   * tool-changer in one command. Use {@link TEMP_NO_CHANGE} (-200) to leave a
+   * tool unchanged or {@link TEMP_OFF} (-100) to turn one off. Must contain
+   * exactly {@link NOZZLE_COUNT} entries.
+   * @param temps Per-tool target temperatures, ordered T0..T3.
+   * @returns A Promise resolving to true if the command is acknowledged.
+   */
+  public async setToolTemps(temps: number[]): Promise<boolean> {
+    if (temps.length !== NOZZLE_COUNT) {
+      console.error(`setToolTemps: expected ${NOZZLE_COUNT} temps, got ${temps.length}.`);
+      return false;
+    }
+    return await this.sendHttpTempCommand({ nozzles: [...temps] });
+  }
+
+  /**
+   * Cancels heating for a single tool/nozzle on a Creator 5 series tool-changer
+   * (sets its target to 0), leaving the other tools unchanged.
+   * @param toolIndex Zero-based tool index (0-3 for T0-T3).
+   * @returns A Promise resolving to true if the command is acknowledged.
+   */
+  public async cancelToolTemp(toolIndex: number): Promise<boolean> {
+    const nozzles = this.buildNozzleArray(toolIndex, TEMP_OFF);
+    if (nozzles === null) return false;
+    return await this.sendHttpTempCommand({ nozzles });
   }
 
   /**
@@ -112,7 +188,9 @@ export class TempControl {
    */
   public async waitForPartCool(temp: number): Promise<void> {
     if (this.client.httpOnly) {
-      console.log('waitForPartCool() unavailable over HTTP-only connection; poll info.get() instead.');
+      console.log(
+        'waitForPartCool() unavailable over HTTP-only connection; poll info.get() instead.'
+      );
       return;
     }
     await this.tcpClient.gCode().waitForBedTemp(temp, true);

src/models/MachineInfo.test.ts

@@ -371,6 +371,8 @@ describe('MachineInfo', () => {
       expect(result.ToolTemps).toHaveLength(4);
       expect(result.ToolTemps[0]).toEqual({ current: 25, set: 0 });
       expect(result.ToolTemps[3]).toEqual({ current: 28, set: 0 });
+      // Tool-changer reports its real nozzle count, not 1.
+      expect(result.NozzleCount).toBe(4);
       // Extruder mirrors the first tool's source field (rightTemp absent -> 0).
       expect(result.Extruder.current).toBe(0);
 
@@ -418,6 +420,7 @@ describe('MachineInfo', () => {
 
       expect(result.ToolTemps).toHaveLength(1);
       expect(result.ToolTemps[0]).toEqual({ current: 210.3, set: 210 });
+      expect(result.NozzleCount).toBe(1);
       expect(result.HasDoorSensor).toBe(false);
     });
   });

src/models/MachineInfo.ts

@@ -77,8 +77,7 @@ export class MachineInfo {
         isCreator5 = (detail.name || '').includes('Creator 5');
         // `model` is the immutable factory name; prefer it over the user-mutable
         // `name` when distinguishing the Pro variant without a pid.
-        isCreator5Pro =
-          isCreator5 && /Creator 5 Pro/i.test(detail.model || detail.name || '');
+        isCreator5Pro = isCreator5 && /Creator 5 Pro/i.test(detail.model || detail.name || '');
       }
 
       // Per-tool temperatures. Creator 5 series report `nozzleTemps[]` /
@@ -103,10 +102,7 @@ export class MachineInfo {
       const hasLidar = detail.lidar === 1;
       const hasDoorSensor = isCreator5Pro;
       const model =
-        detail.model ||
-        (pid !== undefined ? PID_MODEL_NAMES[pid] : undefined) ||
-        detail.name ||
-        '';
+        detail.model || (pid !== undefined ? PID_MODEL_NAMES[pid] : undefined) || detail.name || '';
       const printEta = this.formatTimeFromSeconds(detail.estimatedTime || 0);
       const completionTime = new Date(Date.now() + (detail.estimatedTime || 0) * 1000);
       const formattedRunTime = this.formatTimeFromSeconds(detail.printDuration || 0);
@@ -178,6 +174,9 @@ export class MachineInfo {
         IsCreator5Pro: isCreator5Pro,
         Model: model,
         NozzleSize: detail.nozzleModel || '',
+        // Prefer the firmware-reported count; fall back to the parsed per-tool
+        // array length so single-nozzle models still report 1.
+        NozzleCount: detail.nozzleCnt || toolTemps.length,
 
         // Capabilities (presence-derived)
         HasCamera: hasCamera,

src/models/ff-models.ts

@@ -260,6 +260,8 @@ export interface FFMachineInfo {
   Model: string;
   /** Nozzle size (e.g., "0.4mm"). */
   NozzleSize: string;
+  /** Number of tools/nozzles the printer reports (`detail.nozzleCnt`). Creator 5 series = 4 (tool-changer); single-nozzle models = 1. Mirrors the length of {@link ToolTemps}. */
+  NozzleCount: number;
 
   /** Whether the printer has a built-in camera (capability flag, not just stream availability). */
   HasCamera: boolean;