flashforge-python-api 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

flashforge/__init__.py

@@ -127,7 +127,7 @@ from .tcp import (
 )
 
 FiveMClient = FlashForgeClient
-__version__ = "1.2.2"
+__version__ = "1.3.0"
 __author__ = "FlashForge Python API Contributors"
 __email__ = "notghosttypes@gmail.com"
 __description__ = "Python library for controlling FlashForge 3D printers"

flashforge/api/constants/commands.py

@@ -9,3 +9,7 @@ class Commands:
     CIRCULATION_CONTROL_CMD = "circulateCtl_cmd"
     CAMERA_CONTROL_CMD = "streamCtrl_cmd"
     TEMP_CONTROL_CMD = "temperatureCtl_cmd"
+    # AD5X + Creator 5 material-station slot metadata (name + color). Filament
+    # load/unload (`ms_cmd`) stays AD5X-only — the Creator 5 firmware has no
+    # `ms_cmd` (confirmed via Ghidra RE).
+    MATERIAL_STATION_CONFIG_CMD = "msConfig_cmd"

flashforge/api/constants/endpoints.py

@@ -1,6 +1,5 @@
 from typing import Final
 
-
 CAMERA_STREAM_PORT: Final[int] = 8080
 
 

flashforge/api/controls/control.py

@@ -8,6 +8,7 @@ from ...models.responses import FilamentArgs
 from ..constants.commands import Commands
 from ..constants.endpoints import Endpoints
 from ..network.utils import NetworkUtils, json_from_response
+from .creator5_palette import snap_to_creator5_palette
 
 if TYPE_CHECKING:
     from ...client import FlashForgeClient
@@ -43,8 +44,11 @@ class Control:
         Homes the X, Y, and Z axes of the printer.
 
         Returns:
-            True if the command is successful, False otherwise.
+            True if the command is successful, False otherwise (including when the
+            printer has no TCP control channel, e.g. Creator 5).
         """
+        if not self.client.can_use_tcp("home_axes"):
+            return False
         return await self.tcp_client.home_axes()
 
     async def home_axes_rapid(self) -> bool:
@@ -52,8 +56,11 @@ class Control:
         Performs a rapid homing of the X, Y, and Z axes.
 
         Returns:
-            True if the command is successful, False otherwise.
+            True if the command is successful, False otherwise (including when the
+            printer has no TCP control channel, e.g. Creator 5).
         """
+        if not self.client.can_use_tcp("home_axes_rapid"):
+            return False
         return await self.tcp_client.rapid_home()
 
     async def set_external_filtration_on(self) -> bool:
@@ -202,8 +209,11 @@ class Control:
         Turns on the filament runout sensor.
 
         Returns:
-            True if the command is successful, False otherwise.
+            True if the command is successful, False otherwise (including when the
+            printer has no TCP control channel, e.g. Creator 5).
         """
+        if not self.client.can_use_tcp("turn_runout_sensor_on"):
+            return False
         return await self.tcp_client.turn_runout_sensor_on()
 
     async def turn_runout_sensor_off(self) -> bool:
@@ -211,10 +221,61 @@ class Control:
         Turns off the filament runout sensor.
 
         Returns:
-            True if the command is successful, False otherwise.
+            True if the command is successful, False otherwise (including when the
+            printer has no TCP control channel, e.g. Creator 5).
         """
+        if not self.client.can_use_tcp("turn_runout_sensor_off"):
+            return False
         return await self.tcp_client.turn_runout_sensor_off()
 
+    async def configure_slot(self, slot: int, material_name: str, hex_rgb: str) -> bool:
+        """
+        Configures the material name and color metadata for a material-station slot.
+        This information is shown on the printer UI and used for print validation; it
+        does not move any filament. Available on the AD5X and the Creator 5 / Creator 5 Pro.
+
+        The ``msConfig_cmd`` handler is firmware-confirmed present on the Creator 5
+        (Ghidra RE of ``firmwareExe`` 1.9.2). The Creator 5 has no removable IFS; it
+        surfaces its 4 tool heads as the 4 "slots", so this sets per-tool material
+        metadata. Both models share the same ``OrcaServer`` command path and wire
+        format. Note that **filament load/unload (``slotAction`` / ``ms_cmd``)
+        remains AD5X-only** — the Creator 5 firmware has no ``ms_cmd``.
+
+        The firmware accepts arbitrary material strings, but the two models render
+        the slot color icon differently:
+
+         - AD5X: accepts freeform hex (the leading "#" is stripped before sending).
+         - Creator 5 / 5 Pro: renders an icon ONLY when ``rgb`` is a byte-for-byte,
+           case-sensitive match against the firmware's 24-entry palette (WITH the
+           "#"); any other value falls back to White. This method snaps the
+           caller's color to the nearest palette entry automatically for the Creator 5.
+
+        Args:
+            slot: The slot number (1-4).
+            material_name: The material type (e.g., "PLA", "PETG").
+            hex_rgb: The color as a hex string.
+
+        Returns:
+            True if the command is successful, False otherwise.
+        """
+        if not self.client.is_ad5x and not self.client.is_creator5:
+            print("configure_slot() error, material station only available on AD5X / Creator 5.")
+            return False
+        # The AD5X and Creator 5 use MUTUALLY EXCLUSIVE color wire formats (see
+        # creator5_palette for the firmware match rules), so model-gate here:
+        #  - AD5X: freeform hex, the leading "#" stripped ("RRGGBB"). Unchanged.
+        #  - Creator 5 / 5 Pro: the firmware renders an icon ONLY on a byte-for-byte
+        #    match against its 24-entry palette (case-sensitive, WITH the "#"). Snap
+        #    the caller's color to the nearest palette entry in uppercase "#RRGGBB".
+        if self.client.is_creator5:
+            rgb = snap_to_creator5_palette(hex_rgb).hex
+        else:
+            rgb = hex_rgb[1:] if hex_rgb.startswith("#") else hex_rgb
+        return await self.send_control_command(
+            Commands.MATERIAL_STATION_CONFIG_CMD,
+            {"slot": slot, "mt": material_name, "rgb": rgb},
+        )
+
     async def send_control_command(self, command: str, args: dict[str, Any]) -> bool:
         """
         Sends a generic control command to the printer via HTTP POST.

flashforge/api/controls/creator5_palette.py

@@ -0,0 +1,255 @@
+"""
+FlashForge Python API - Creator 5 / Creator 5 Pro material-station slot color
+palette and perceptual nearest-color snapping.
+
+The Creator 5 ``msConfig_cmd`` only renders a color icon when the ``rgb`` field is
+an EXACT, case-sensitive, byte-for-byte match against one of the firmware's 24
+built-in palette strings (compared via ``std::operator==`` in ``firmwareExe``
+1.9.2). A non-match leaves the slot's color index at 0 (White). These values
+DIFFER from the AD5X palette (e.g. Blue is ``#4CAAF8`` here vs ``#45A8F9`` on the
+AD5X), so callers must snap against THIS list specifically.
+
+By contrast the AD5X accepts freeform hex (with the ``#`` stripped), so the two
+wire formats are mutually exclusive — see :func:`flashforge.api.controls.control.Control.configure_slot`
+for the model-gating that splits them.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+from dataclasses import dataclass
+
+# The color-space math in this module mirrors the published CIEDE2000 / CIE L*a*b*
+# notation (L, a, b, C', h', etc.) verbatim so it can be checked against the
+# reference. PEP 8 lowercase locals are therefore relaxed here on purpose.
+# ruff: noqa: N806
+
+
+@dataclass(frozen=True)
+class Creator5PaletteColor:
+    """A single entry in the Creator 5 firmware color palette."""
+
+    index: int
+    """Firmware palette index (0 = White = the no-match fallback)."""
+
+    name: str
+    """Color name as shown on the printer UI."""
+
+    hex: str  # noqa: N815 - field mirrors the TS `hex` property name
+    """Wire value sent to the printer, always uppercase ``#RRGGBB``."""
+
+
+#: The firmware's 24-entry UI palette (firmwareExe 1.9.2, Ghidra-confirmed).
+#: Index 0 (White) is also what the firmware falls back to on a no-match.
+CREATOR5_PALETTE: tuple[Creator5PaletteColor, ...] = (
+    Creator5PaletteColor(0, "White", "#FFFFFF"),
+    Creator5PaletteColor(1, "Yellow", "#FFF245"),
+    Creator5PaletteColor(2, "Light Green", "#DEF578"),
+    Creator5PaletteColor(3, "Green", "#21CC3D"),
+    Creator5PaletteColor(4, "Dark Green", "#167A4B"),
+    Creator5PaletteColor(5, "Teal", "#156682"),
+    Creator5PaletteColor(6, "Cyan", "#24E4A0"),
+    Creator5PaletteColor(7, "Light Blue", "#7BD9F0"),
+    Creator5PaletteColor(8, "Blue", "#4CAAF8"),
+    Creator5PaletteColor(9, "Dark Blue", "#2E54DD"),
+    Creator5PaletteColor(10, "Purple", "#48358C"),
+    Creator5PaletteColor(11, "Violet", "#A341F7"),
+    Creator5PaletteColor(12, "Magenta", "#F435F6"),
+    Creator5PaletteColor(13, "Pink", "#D5B4DE"),
+    Creator5PaletteColor(14, "Coral", "#FA6173"),
+    Creator5PaletteColor(15, "Red", "#F82D29"),
+    Creator5PaletteColor(16, "Brown", "#805003"),
+    Creator5PaletteColor(17, "Orange", "#F9903B"),
+    Creator5PaletteColor(18, "Cream", "#FCEBD7"),
+    Creator5PaletteColor(19, "Tan", "#D5C5A1"),
+    Creator5PaletteColor(20, "Dark Brown", "#B17C38"),
+    Creator5PaletteColor(21, "Gray", "#8C8C89"),
+    Creator5PaletteColor(22, "Light Gray", "#BEBEBE"),
+    Creator5PaletteColor(23, "Black", "#1B1B1B"),
+)
+
+# 25^7, the CIEDE2000 chroma weighting constant.
+_25_POW_7 = 25.0 ** 7
+
+# D65 reference white point used by the sRGB -> XYZ transform.
+_D65_XN = 0.95047
+_D65_YN = 1.0
+_D65_ZN = 1.08883
+
+
+def _srgb_to_linear(channel: float) -> float:
+    """sRGB component (0-255) channel transfer function -> linear value (0-1)."""
+    c = channel / 255.0
+    return c / 12.92 if c <= 0.04045 else ((c + 0.055) / 1.055) ** 2.4
+
+
+def _rgb_to_lab(r: float, g: float, b: float) -> tuple[float, float, float]:
+    """
+    Converts an sRGB color (0-255 channels) to CIE L*a*b* under a D65 illuminant.
+    Used as the perceptual basis for the CIEDE2000 nearest-color match.
+    """
+    R = _srgb_to_linear(r)
+    G = _srgb_to_linear(g)
+    B = _srgb_to_linear(b)
+
+    x = R * 0.4124564 + G * 0.3575761 + B * 0.1804375
+    y = R * 0.2126729 + G * 0.7151522 + B * 0.072175
+    z = R * 0.0193339 + G * 0.119192 + B * 0.9503041
+
+    x /= _D65_XN
+    y /= _D65_YN
+    z /= _D65_ZN
+
+    def f(t: float) -> float:
+        return math.cbrt(t) if t > 0.008856 else 7.787 * t + 16.0 / 116.0
+
+    fx = f(x)
+    fy = f(y)
+    fz = f(z)
+
+    return (116.0 * fy - 16.0, 500.0 * (fx - fy), 200.0 * (fy - fz))
+
+
+def _atan2_deg(ordinate: float, abscissa: float) -> float:
+    """atan2 -> hue in degrees, normalized to [0, 360)."""
+    h = math.degrees(math.atan2(ordinate, abscissa))
+    if h < 0:
+        h += 360.0
+    return h
+
+
+def _delta_e_2000(c1: tuple[float, float, float], c2: tuple[float, float, float]) -> float:
+    """
+    CIEDE2000 color difference between two L*a*b* colors (kL=kC=kH=1). This is the
+    most accurate standard delta-E metric and is preferred here because the
+    firmware renders only an exact palette match — snapping to the wrong
+    perceptual neighbor would display the wrong color on the printer.
+    """
+    L1, a1, b1 = c1
+    L2, a2, b2 = c2
+
+    C1 = math.sqrt(a1 * a1 + b1 * b1)
+    C2 = math.sqrt(a2 * a2 + b2 * b2)
+    Cbar = (C1 + C2) / 2.0
+    Cbar7 = Cbar ** 7
+    G = 0.5 * (1 - math.sqrt(Cbar7 / (Cbar7 + _25_POW_7)))
+
+    a1p = (1 + G) * a1
+    a2p = (1 + G) * a2
+    C1p = math.sqrt(a1p * a1p + b1 * b1)
+    C2p = math.sqrt(a2p * a2p + b2 * b2)
+    h1p = _atan2_deg(b1, a1p)
+    h2p = _atan2_deg(b2, a2p)
+
+    dLp = L2 - L1
+    dCp = C2p - C1p
+    if C1p * C2p == 0:
+        dhp = 0.0
+    else:
+        diff = h2p - h1p
+        if abs(diff) <= 180:
+            dhp = diff
+        elif diff > 180:
+            dhp = diff - 360
+        else:
+            dhp = diff + 360
+    dHp = 2 * math.sqrt(C1p * C2p) * math.sin(math.radians(dhp) / 2.0)
+
+    Lbarp = (L1 + L2) / 2.0
+    Cbarp = (C1p + C2p) / 2.0
+    if C1p * C2p == 0:
+        hbarp = h1p + h2p
+    else:
+        diff = abs(h1p - h2p)
+        if diff <= 180:
+            hbarp = (h1p + h2p) / 2.0
+        elif h1p + h2p < 360:
+            hbarp = (h1p + h2p + 360) / 2.0
+        else:
+            hbarp = (h1p + h2p - 360) / 2.0
+
+    T = (
+        1
+        - 0.17 * math.cos(math.radians(hbarp - 30))
+        + 0.24 * math.cos(math.radians(2 * hbarp))
+        + 0.32 * math.cos(math.radians(3 * hbarp + 6))
+        - 0.20 * math.cos(math.radians(4 * hbarp - 63))
+    )
+
+    dTheta = 30 * math.exp(-(((hbarp - 275) / 25.0) ** 2))
+    Cbarp7 = Cbarp ** 7
+    RC = 2 * math.sqrt(Cbarp7 / (Cbarp7 + _25_POW_7))
+    SL = 1 + (0.015 * (Lbarp - 50) ** 2) / math.sqrt(20 + (Lbarp - 50) ** 2)
+    SC = 1 + 0.045 * Cbarp
+    SH = 1 + 0.015 * Cbarp * T
+    RT = -math.sin(math.radians(2 * dTheta)) * RC
+
+    termL = dLp / SL
+    termC = dCp / SC
+    termH = dHp / SH
+
+    return math.sqrt(termL * termL + termC * termC + termH * termH + RT * termC * termH)
+
+
+_HEX_RE = re.compile(r"^[0-9a-fA-F]{3}([0-9a-fA-F]{3})?$")
+
+
+def _hex_to_rgb(hex_str: str) -> tuple[int, int, int] | None:
+    """
+    Parses a hex color string (``#RRGGBB``, ``RRGGBB``, 3-digit shorthand, any
+    case) into its RGB channels. Returns None for unparseable input.
+    """
+    clean = hex_str.strip()
+    # Remove a single leading "#" (matches the TS replace(/^#/, '')).
+    if clean.startswith("#"):
+        clean = clean[1:]
+    if not _HEX_RE.match(clean):
+        return None
+    if len(clean) == 3:
+        clean = "".join(ch + ch for ch in clean)
+    return (int(clean[0:2], 16), int(clean[2:4], 16), int(clean[4:6], 16))
+
+
+# Palette entries with their L*a*b* values precomputed once at module load.
+_PALETTE_LAB: list[tuple[Creator5PaletteColor, tuple[float, float, float]]] = []
+for _color in CREATOR5_PALETTE:
+    _rgb = _hex_to_rgb(_color.hex)
+    if _rgb is None:
+        _rgb = (0, 0, 0)
+    _PALETTE_LAB.append((_color, _rgb_to_lab(_rgb[0], _rgb[1], _rgb[2])))
+
+
+def snap_to_creator5_palette(hex_str: str) -> Creator5PaletteColor:
+    """
+    Snaps an arbitrary hex color to the nearest entry in the Creator 5 firmware
+    palette using the CIEDE2000 perceptual distance in CIE L*a*b* space.
+
+    The returned :attr:`Creator5PaletteColor.hex` is always uppercase ``#RRGGBB``
+    and is guaranteed to be a byte-for-byte firmware match. Unparseable input
+    falls back to White (index 0, the firmware's own no-match fallback) with a
+    warning.
+
+    Args:
+        hex_str: The caller's color as a hex string (leading ``#`` optional, any case).
+
+    Returns:
+        The nearest Creator 5 palette entry.
+    """
+    rgb = _hex_to_rgb(hex_str)
+    if rgb is None:
+        print(
+            f'snap_to_creator5_palette: could not parse "{hex_str}" as hex; '
+            "falling back to White."
+        )
+        return CREATOR5_PALETTE[0]
+
+    target = _rgb_to_lab(rgb[0], rgb[1], rgb[2])
+    best = _PALETTE_LAB[0]
+    best_delta = float("inf")
+    for entry in _PALETTE_LAB:
+        delta = _delta_e_2000(target, entry[1])
+        if delta < best_delta:
+            best_delta = delta
+            best = entry
+    return best[0]

flashforge/api/controls/files.py

@@ -35,10 +35,18 @@ class Files:
         """
         Retrieves a list of files stored locally on the printer.
 
+        HTTP-only printers (Creator 5 / 5 Pro) have no TCP/8899 file-listing
+        channel, so this falls back to the HTTP ``/gcodeList`` recent-file list
+        (mirroring ``Files.ts``) instead of hanging on a dead TCP socket.
+
         Returns:
             A list of file names, or empty list if retrieval fails.
         """
-        # This method uses the TCP client to get file list
+        if self.client.http_only:
+            entries = await self.get_recent_file_list()
+            return [e.gcode_file_name for e in entries if e.gcode_file_name]
+
+        # Legacy / 5M-family printers expose the file list over TCP.
         if hasattr(self.client, "tcp_client") and self.client.tcp_client:
             return await self.client.tcp_client.get_file_list_async()
         return []
@@ -47,6 +55,9 @@ class Files:
         """
         Retrieves a list of files stored locally on the printer.
 
+        HTTP-only printers (Creator 5 / 5 Pro) have no TCP/8899 file-listing
+        channel; see :meth:`get_file_list` for the HTTP fallback.
+
         Returns:
             A list of file names, or empty list if retrieval fails.
         """

flashforge/api/controls/info.py

@@ -2,6 +2,7 @@
 FlashForge Python API - Info Module
 """
 
+import re
 from datetime import datetime, timedelta
 from typing import TYPE_CHECKING
 
@@ -14,6 +15,32 @@ if TYPE_CHECKING:
     from ...client import FlashForgeClient
 
 
+# Firmware-reported PIDs from FlashForge's /detail endpoint. These are stable
+# identifiers set by firmware, unlike the user-mutable `name` field.
+PID_5M = 35
+PID_5M_PRO = 36
+PID_AD5X = 38
+PID_CREATOR5 = 40
+PID_CREATOR5_PRO = 41
+KNOWN_HTTP_PIDS = {
+    PID_5M,
+    PID_5M_PRO,
+    PID_AD5X,
+    PID_CREATOR5,
+    PID_CREATOR5_PRO,
+}
+
+# Immutable model display names keyed by firmware PID. Used as a fallback for
+# `model` when the printer doesn't report the `model` field (older firmware).
+PID_MODEL_NAMES: dict[int, str] = {
+    PID_5M: "Adventurer 5M",
+    PID_5M_PRO: "Adventurer 5M Pro",
+    PID_AD5X: "AD5X",
+    PID_CREATOR5: "Creator 5",
+    PID_CREATOR5_PRO: "Creator 5 Pro",
+}
+
+
 class MachineInfoParser:
     """
     Transforms printer detail data from the API response format into a structured FFMachineInfo object.
@@ -68,8 +95,74 @@ class MachineInfoParser:
                 or len(getattr(getattr(detail, "matl_station_info", None), "slot_infos", []) or []) > 0
             )
             printer_name = getattr(detail, "name", "") or ""
-            is_ad5x = printer_name.upper() == "AD5X" or has_material_station
-            is_pro = "Pro" in printer_name and not is_ad5x
+            pid = getattr(detail, "pid", None)
+            detail_model = getattr(detail, "model", None) or ""
+
+            if pid in KNOWN_HTTP_PIDS:
+                is_ad5x = pid == PID_AD5X
+                is_pro = pid == PID_5M_PRO
+                is_creator5 = pid in (PID_CREATOR5, PID_CREATOR5_PRO)
+                is_creator5_pro = pid == PID_CREATOR5_PRO
+            else:
+                # Fallback for firmware that doesn't report pid: legacy
+                # name+capability heuristic. Vulnerable to user renames, which
+                # is why pid-based detection is preferred when available.
+                #
+                # IMPORTANT: detect the Creator 5 family *first*. A user-set
+                # name like "Creator 5 Pro" contains "Pro", so a naive
+                # `"Pro" in name` check would mis-classify it as a 5M Pro.
+                is_creator5 = "Creator 5" in printer_name
+                is_creator5_pro = is_creator5 and bool(
+                    re.search(r"Creator 5 Pro", detail_model or printer_name, re.IGNORECASE)
+                )
+                is_ad5x = (
+                    printer_name.upper() == "AD5X" or has_material_station
+                ) and not is_creator5
+                is_pro = "Pro" in printer_name and not is_ad5x and not is_creator5
+
+            # Per-tool temperatures. Creator 5 series report nozzleTemps[] /
+            # nozzleTargetTemps[]; single-nozzle models don't, so fall back to a
+            # 1-element array mirroring the right/main extruder.
+            nozzle_temps = getattr(detail, "nozzle_temps", None)
+            nozzle_target_temps = getattr(detail, "nozzle_target_temps", None)
+            if nozzle_temps:
+                tool_temps = [
+                    Temperature(
+                        current=t or 0.0,
+                        set=(
+                            nozzle_target_temps[i]
+                            if nozzle_target_temps and i < len(nozzle_target_temps)
+                            else 0.0
+                        )
+                        or 0.0,
+                    )
+                    for i, t in enumerate(nozzle_temps)
+                ]
+            else:
+                tool_temps = [
+                    Temperature(
+                        current=getattr(detail, "right_temp", 0) or 0.0,
+                        set=getattr(detail, "right_target_temp", 0) or 0.0,
+                    )
+                ]
+
+            # Capability flags. Derived from presence/value, never assumed from
+            # the model family alone. Only the Creator 5 Pro has a confirmed
+            # door sensor; on every other model `doorStatus` is cosmetic.
+            has_camera = getattr(detail, "camera", None) == 1 or bool(
+                getattr(detail, "camera_stream_url", "") or ""
+            )
+            has_lidar = getattr(detail, "lidar", None) == 1
+            has_door_sensor = is_creator5_pro
+
+            # Immutable model name resolution: prefer the firmware `model`
+            # field, then a PID-derived name, then the user-set name.
+            pid_model_name = PID_MODEL_NAMES.get(pid) if pid is not None else None
+            model_value = detail_model or pid_model_name or printer_name or ""
+
+            # Prefer the firmware-reported nozzle count; fall back to the parsed
+            # per-tool array length so single-nozzle models still report 1.
+            nozzle_count = getattr(detail, "nozzle_cnt", None) or len(tool_temps)
 
             # Build the FFMachineInfo object
             machine_info = FFMachineInfo(
@@ -107,9 +200,14 @@ class MachineInfoParser:
                 fill_amount=getattr(detail, "fill_amount", 0) or 0,
                 firmware_version=getattr(detail, "firmware_version", "") or "",
                 name=printer_name,
+                pid=pid,
                 is_pro=is_pro,
                 is_ad5x=is_ad5x,
+                is_creator5=is_creator5,
+                is_creator5_pro=is_creator5_pro,
+                model=model_value,
                 nozzle_size=getattr(detail, "nozzle_model", "") or "",
+                nozzle_count=nozzle_count,
                 # Temperatures
                 print_bed=Temperature(
                     current=getattr(detail, "plat_temp", 0) or 0,
@@ -119,6 +217,15 @@ class MachineInfoParser:
                     current=getattr(detail, "right_temp", 0) or 0,
                     set=getattr(detail, "right_target_temp", 0) or 0,
                 ),
+                chamber=Temperature(
+                    current=getattr(detail, "chamber_temp", 0) or 0,
+                    set=getattr(detail, "chamber_target_temp", 0) or 0,
+                ),
+                tool_temps=tool_temps,
+                # Capability flags (presence-derived)
+                has_camera=has_camera,
+                has_lidar=has_lidar,
+                has_door_sensor=has_door_sensor,
                 # Current print stats
                 print_duration=getattr(detail, "print_duration", 0) or 0,
                 print_file_name=getattr(detail, "print_file_name", "") or "",