1 주 전 · 736e0b0f62
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
--- a/README.md
+++ b/README.md
@@ -293,7 +293,7 @@ Optional but recommended — drop the [`slicer-api/` Compose stack](slicer-api/R
 
				 - **Bulk spool addition** — Add multiple identical spools at once (quantity 1–100) with a single form submission. Quick Add mode for stock spools that only need material, color, and weight.
			
 
				 - Spool catalog, color catalog, PA profile matching, and low-stock alerts
			
 
				 - **Multi-colour gradients, transparency, and visual effects** — Paste a comma-separated hex list (e.g. from 3dfilamentprofiles.com) to render a spool as a gradient or conic colour wheel; transparency shows through a checkerboard so the alpha you set is the alpha you see; pick a visual effect (sparkle, wood, marble, glow, matte) for the swatch overlay. Same fields are editable on the colour catalog so combos can be reused across spools.
			
 
				-- **Printable spool labels** — Generate PDF labels for any selection of spools in four pre-built sizes: AMS holder (30×15 mm), box label (62×29 mm), Avery L7160 sheet (A4, 21 per page), and Avery 5160 sheet (US Letter, 30 per page). Each label shows the colour swatch, brand, material, name, the **spool ID** (for at-a-glance identification across many similar spools), and a QR code that deep-links straight back to the spool's row in Bambuddy when scanned with a phone. Pick from the inventory page — search, filter by material, multi-select spools, then print or save to PDF.
			
 
				+- **Printable spool labels** — Generate PDF labels for any selection of spools in four pre-built sizes: AMS holder (30×15 mm), box label (62×29 mm), Avery L7160 sheet (A4, 21 per page), and Avery 5160 sheet (US Letter, 30 per page). Each label shows the colour swatch, brand, material, name, the **spool ID** (for at-a-glance identification across many similar spools), and a QR code that deep-links straight back to the spool's row in Bambuddy when scanned with a phone. Pick from the inventory page — search, filter by material, multi-select spools, then print or save to PDF. For a partially used Avery sheet, choose the first unused label position; Bambuddy leaves the earlier positions blank and starts later pages from position 1.
			
 
				 
			
 
				 ### 🔧 Integrations
			
 
				 - [Spoolman](https://github.com/Donkie/Spoolman) filament sync with per-filament usage tracking and fill level display
			
--- a/assert
+++ b/assert
--- a/backend/app/api/routes/_spoolman_helpers.py
+++ b/backend/app/api/routes/_spoolman_helpers.py
@@ -28,6 +28,8 @@ class MappedSpoolFields(TypedDict):
 
				     color_name: str | None
			
 
				     color_name_is_synthesized: bool
			
 
				     rgba: str | None
			
 
				+    extra_colors: str | None
			
 
				+    effect_type: None
			
 
				     label_weight: int | None
			
 
				     core_weight: int | None
			
 
				     core_weight_catalog_id: None
			
@@ -91,7 +93,10 @@ def assert_safe_spoolman_url(url: str) -> None:
 
				     assert_safe_lan_service_url(url, label="Spoolman URL")
			
 
				 
			
 
				 
			
 
				-_COLOR_HEX_RE = re.compile(r"^[0-9A-Fa-f]{6}$")
			
 
				+# Six characters, or eight when the filament carries an alpha byte. The write
			
 
				+# side stores eight only for genuinely translucent spools (#2912); rejecting
			
 
				+# them here turned every clear spool into neutral grey on read.
			
 
				+_COLOR_HEX_RE = re.compile(r"^[0-9A-Fa-f]{6}(?:[0-9A-Fa-f]{2})?$")
			
 
				 _TAG_HEX_RE = re.compile(r"^[0-9A-F]+$")
			
 
				 
			
 
				 
			
@@ -153,6 +158,30 @@ def _extract_extra_str(extra: dict, key: str) -> str:
 
				     return decoded if isinstance(decoded, str) else ""
			
 
				 
			
 
				 
			
 
				+def parse_spoolman_multi_colors(filament: dict) -> list[str]:
			
 
				+    """Spoolman's ``multi_color_hexes`` as a list of bare 6/8-char hex tokens.
			
 
				+
			
 
				+    Spoolman stores the extra stops of a gradient / dual / multi-colour
			
 
				+    filament here, and writes the field as a comma-separated string in some
			
 
				+    releases and a list in others -- both shapes are accepted. Tokens keep the
			
 
				+    case they arrived in and lose any leading ``#``, which is the form
			
 
				+    ``Spool.extra_colors`` stores and ``parseStops`` on the client expects.
			
 
				+
			
 
				+    Shared with the label renderer rather than parsed twice: the two read the
			
 
				+    same field for the same purpose, and a swatch on a printer card that
			
 
				+    disagreed with the swatch on the printed label would be worse than either
			
 
				+    being wrong on its own.
			
 
				+    """
			
 
				+    raw = filament.get("multi_color_hexes")
			
 
				+    if isinstance(raw, str):
			
 
				+        tokens = raw.split(",")
			
 
				+    elif isinstance(raw, list):
			
 
				+        tokens = [str(token) for token in raw]
			
 
				+    else:
			
 
				+        return []
			
 
				+    return [cleaned for token in tokens if (cleaned := token.strip().lstrip("#"))]
			
 
				+
			
 
				+
			
 
				 def _map_spoolman_spool(spool: dict) -> MappedSpoolFields:
			
 
				     """Convert a raw Spoolman spool dict to the InventorySpool-compatible format.
			
 
				 
			
@@ -197,10 +226,19 @@ def _map_spoolman_spool(spool: dict) -> MappedSpoolFields:
 
				     else:
			
 
				         subtype = filament_name or None
			
 
				 
			
 
				-    # Colour: validate as 6-char hex; fall back to neutral grey for invalid values
			
 
				+    # Colour: validate as 6- or 8-char hex; fall back to neutral grey for invalid
			
 
				+    # values. An 8-char value already carries its alpha, so appending the opaque
			
 
				+    # byte would push it to ten and lose the translucency it was stored to keep.
			
 
				     raw_color = (filament.get("color_hex") or "").upper().removeprefix("#")
			
 
				     color_hex: str = raw_color if _COLOR_HEX_RE.match(raw_color) else "808080"
			
 
				-    rgba: str = color_hex + "FF"
			
 
				+    rgba: str = color_hex if len(color_hex) == 8 else color_hex + "FF"
			
 
				+    # Spoolman carries the extra stops but has no concept of a surface effect
			
 
				+    # -- its only neighbouring field is `multi_color_direction`, which says how
			
 
				+    # the stops are laid out, not that the filament is silk or glitter. So a
			
 
				+    # Spoolman spool can render its gradient and never an effect overlay, and
			
 
				+    # `effect_type` is pinned to None rather than guessed at.
			
 
				+    extra_stops = parse_spoolman_multi_colors(filament)
			
 
				+    extra_colors: str | None = ",".join(extra_stops) if extra_stops else None
			
 
				 
			
 
				     label_weight: int = _safe_int(filament.get("weight"), 1000)
			
 
				     real_used_weight: float = _safe_float(spool.get("used_weight"), 0.0)
			
@@ -265,6 +303,8 @@ def _map_spoolman_spool(spool: dict) -> MappedSpoolFields:
 
				         "color_name": color_name,
			
 
				         "color_name_is_synthesized": color_name_is_synthesized,
			
 
				         "rgba": rgba,
			
 
				+        "extra_colors": extra_colors,
			
 
				+        "effect_type": None,
			
 
				         "brand": vendor.get("name") or None,
			
 
				         "label_weight": label_weight,
			
 
				         "core_weight": _safe_int(
			
--- a/backend/app/api/routes/archives.py
+++ b/backend/app/api/routes/archives.py
@@ -1,3 +1,4 @@
 
				+import asyncio
			
 
				 import io
			
 
				 import json
			
 
				 import logging
			
@@ -13,39 +14,53 @@ from fastapi.responses import FileResponse, Response
 
				 from sqlalchemy import and_, case, func, or_, select
			
 
				 from sqlalchemy.ext.asyncio import AsyncSession
			
 
				 
			
 
				+from backend.app.core import database
			
 
				 from backend.app.core.auth import (
			
 
				     RequireCameraStreamTokenIfAuthEnabled,
			
 
				     RequirePermissionIfAuthEnabled,
			
 
				+    check_printer_access,
			
 
				+    current_api_key_if_present,
			
 
				+    probe_permissions_if_auth_enabled,
			
 
				     require_ownership_permission,
			
 
				 )
			
 
				 from backend.app.core.config import settings
			
 
				 from backend.app.core.database import get_db
			
 
				 from backend.app.core.permissions import Permission
			
 
				+from backend.app.models.api_key import APIKey
			
 
				 from backend.app.models.archive import PrintArchive
			
 
				 from backend.app.models.filament import Filament
			
 
				+from backend.app.models.printer import Printer
			
 
				 from backend.app.models.spool_usage_history import SpoolUsageHistory
			
 
				 from backend.app.models.user import User
			
 
				 from backend.app.schemas.archive import ArchiveResponse, ArchiveSlim, ArchiveStats, ArchiveUpdate
			
 
				 from backend.app.schemas.print_log import PrintLogResponse
			
 
				 from backend.app.schemas.slicer import SliceRequest
			
 
				 from backend.app.services.archive import ArchiveService
			
 
				+from backend.app.services.bambu_ftp import ftps_handshake_blocked, list_files_result_async
			
 
				 from backend.app.services.design_settings import overrides_from_config
			
 
				 from backend.app.services.filament_requirements import annotate_rack_groups
			
 
				-from backend.app.services.print_storage import REASON_INTERNAL_STORAGE, REASON_NO_EXTERNAL_STORAGE
			
 
				+from backend.app.services.print_storage import (
			
 
				+    REASON_INTERNAL_HISTORY,
			
 
				+    REASON_INTERNAL_STORAGE,
			
 
				+    REASON_NO_EXTERNAL_STORAGE,
			
 
				+)
			
 
				+from backend.app.services.printer_media import VIDEO_SUFFIXES, match_ipcam_chunks
			
 
				 from backend.app.utils.archive_paths import archive_photos_dir, find_archive_photo
			
 
				-from backend.app.utils.http import build_content_disposition
			
 
				+from backend.app.utils.http import build_content_disposition, download_error_response, safe_download_filename
			
 
				 from backend.app.utils.threemf_tools import (
			
 
				     default_plate_gcode_name,
			
 
				     expand_to_project_slots,
			
 
				     extract_embedded_presets_from_3mf,
			
 
				     extract_nozzle_mapping_from_3mf,
			
 
				     extract_project_filaments_from_3mf,
			
 
				+    names_carry_gcode,
			
 
				     select_plate_gcode_name,
			
 
				 )
			
 
				 
			
 
				 logger = logging.getLogger(__name__)
			
 
				 
			
 
				 router = APIRouter(prefix="/archives", tags=["archives"])
			
 
				+_PRINTER_MEDIA_LIST_TIMEOUT_SECONDS = 8.0
			
 
				 
			
 
				 # Path of the embedded slicer config inside a BambuStudio/OrcaSlicer 3MF.
			
 
				 _PROJECT_SETTINGS_PATH = "Metadata/project_settings.config"
			
@@ -324,6 +339,7 @@ def archive_to_response(
 
				         "duplicate_sequence": duplicate_sequence,
			
 
				         "original_archive_id": original_archive_id,
			
 
				         "print_name": archive.print_name,
			
 
				+        "plate_id": archive.plate_id,
			
 
				         "print_time_seconds": archive.print_time_seconds,
			
 
				         "filament_used_grams": archive.filament_used_grams,
			
 
				         "filament_type": archive.filament_type,
			
@@ -564,7 +580,13 @@ async def no_3mf_warning(
 
				     # Most specific first. Archives predating this field carry no reason at
			
 
				     # all, so an install with one H2C and three older printers still gets the
			
 
				     # H2C explanation rather than the generic one.
			
 
				-    for candidate in (REASON_INTERNAL_STORAGE, REASON_NO_EXTERNAL_STORAGE):
			
 
				+    #
			
 
				+    # REASON_INTERNAL_HISTORY comes last on purpose, even though it is the
			
 
				+    # narrowest: it is the one cause with no remedy at all -- the file was
			
 
				+    # already on the printer, in an area port 990 does not serve. The two ahead
			
 
				+    # of it each end in something the operator can do, so when an install has
			
 
				+    # both, the actionable explanation is the one worth the banner (#1820).
			
 
				+    for candidate in (REASON_INTERNAL_STORAGE, REASON_NO_EXTERNAL_STORAGE, REASON_INTERNAL_HISTORY):
			
 
				         if candidate in reasons:
			
 
				             return {"has_fallback": True, "reason": candidate}
			
 
				     return {"has_fallback": True, "reason": None}
			
@@ -1177,6 +1199,30 @@ async def get_archive_stats(
 
				     )
			
 
				     prints_by_printer = {str(k): v for k, v in printer_result.all()}
			
 
				 
			
 
				+    # Names for printers the client can no longer look up. The breakdowns above
			
 
				+    # key on the id each run recorded, and deleting a printer while keeping its
			
 
				+    # history leaves that id pointing at nothing, so a chart that used to read
			
 
				+    # "Ultron" fell back to "Printer 1" (#2873). Every run also stored the name
			
 
				+    # it printed on, so the last one recorded is what that id was called. The
			
 
				+    # client still prefers a live printer's current name, which keeps a rename
			
 
				+    # showing up straight away.
			
 
				+    last_named_run = (
			
 
				+        select(func.max(PrintLogEntry.id).label("entry_id"))
			
 
				+        .where(
			
 
				+            PrintLogEntry.printer_id.isnot(None),
			
 
				+            PrintLogEntry.printer_name.isnot(None),
			
 
				+            *base_conditions,
			
 
				+        )
			
 
				+        .group_by(PrintLogEntry.printer_id)
			
 
				+        .subquery()
			
 
				+    )
			
 
				+    name_result = await db.execute(
			
 
				+        select(PrintLogEntry.printer_id, PrintLogEntry.printer_name).join(
			
 
				+            last_named_run, PrintLogEntry.id == last_named_run.c.entry_id
			
 
				+        )
			
 
				+    )
			
 
				+    printer_names = {str(printer_id): name for printer_id, name in name_result.all()}
			
 
				+
			
 
				     # Time accuracy — compare each completed run's actual duration to the
			
 
				     # slicer's estimate on the linked archive. Runs without a linked archive
			
 
				     # (NULL archive_id) or without an estimate are excluded.
			
@@ -1276,6 +1322,7 @@ async def get_archive_stats(
 
				         total_cost=round(total_cost, 2),
			
 
				         prints_by_filament_type=prints_by_filament,
			
 
				         prints_by_printer=prints_by_printer,
			
 
				+        printer_names=printer_names,
			
 
				         average_time_accuracy=average_accuracy,
			
 
				         time_accuracy_by_printer=accuracy_by_printer if accuracy_by_printer else None,
			
 
				         total_energy_kwh=round(total_energy_kwh, 3),
			
@@ -1660,7 +1707,7 @@ async def update_archive(
 
				         )
			
 
				     ),
			
 
				 ):
			
 
				-    """Update archive metadata (tags, notes, cost, is_favorite, project_id)."""
			
 
				+    """Update archive metadata (tags, notes, cost, filament grams, is_favorite, project_id)."""
			
 
				     from sqlalchemy.orm import selectinload
			
 
				 
			
 
				     user, can_modify_all = auth_result
			
@@ -1679,6 +1726,10 @@ async def update_archive(
 
				         if archive.created_by_id != user.id:
			
 
				             raise HTTPException(403, "You can only update your own archives")
			
 
				 
			
 
				+    # Read before the writes below: the mirror needs to know whether the run's
			
 
				+    # figure was inherited from this archive or measured on its own (#1820).
			
 
				+    previous_filament_grams = archive.filament_used_grams
			
 
				+
			
 
				     update_payload = update_data.model_dump(exclude_unset=True)
			
 
				     for field, value in update_payload.items():
			
 
				         setattr(archive, field, value)
			
@@ -1693,7 +1744,12 @@ async def update_archive(
 
				     # entry either. Only the latest entry is touched because that's the run
			
 
				     # the modal is implicitly showing (archive.failure_reason / status are
			
 
				     # overwritten on each reprint to reflect the latest run's outcome).
			
 
				-    mirror_fields = {"failure_reason", "status"}
			
 
				+    # filament_used_grams rides along for the same reason (#1820): the filament
			
 
				+    # totals on the Projects page and in the Prometheus metrics sum the LOG
			
 
				+    # ENTRY's grams, not the archive's, so correcting only the archive would fix
			
 
				+    # the card and leave every aggregate reading the old figure -- or, for a
			
 
				+    # print that archived without its 3MF, no figure at all.
			
 
				+    mirror_fields = {"failure_reason", "status", "filament_used_grams"}
			
 
				     to_mirror = {k: v for k, v in update_payload.items() if k in mirror_fields}
			
 
				     if to_mirror:
			
 
				         from backend.app.models.print_log import PrintLogEntry
			
@@ -1705,6 +1761,18 @@ async def update_archive(
 
				             .limit(1)
			
 
				         )
			
 
				         if latest_entry is not None:
			
 
				+            # ...but never over a figure the run measured for itself. A run's
			
 
				+            # grams come from the tracked spool delta when there is one, and
			
 
				+            # only fall back to copying the archive's estimate when there is
			
 
				+            # not (see _compute_run_filament_grams). Overwriting a measurement
			
 
				+            # with a typed estimate would lose the better number; the case this
			
 
				+            # edit exists for -- a print archived with no 3MF -- leaves the run
			
 
				+            # with nothing at all, so it is covered by the None arm.
			
 
				+            if "filament_used_grams" in to_mirror and not (
			
 
				+                latest_entry.filament_used_grams is None or latest_entry.filament_used_grams == previous_filament_grams
			
 
				+            ):
			
 
				+                del to_mirror["filament_used_grams"]
			
 
				+
			
 
				             for field, value in to_mirror.items():
			
 
				                 setattr(latest_entry, field, value)
			
 
				 
			
@@ -1747,6 +1815,25 @@ async def toggle_favorite(
 
				     return archive
			
 
				 
			
 
				 
			
 
				+async def _spoolman_owns_cost(db: AsyncSession) -> bool:
			
 
				+    """True when per-spool pricing lives in Spoolman rather than in our tables.
			
 
				+
			
 
				+    Both cost recalculations below rebuild a print's cost from
			
 
				+    ``SpoolUsageHistory``, and fall back to the built-in Filament catalogue or
			
 
				+    the global default rate when there are no rows for it. In Spoolman mode
			
 
				+    there are never any rows -- the built-in usage tracker is handed
			
 
				+    ``spoolman_owns_usage`` at print start and writes none -- so that fallback
			
 
				+    is not a recalculation, it is a downgrade: it would overwrite the
			
 
				+    Spoolman-priced figure ``spoolman_tracking`` recorded at completion with a
			
 
				+    default-rate one, and the per-slot spool resolution it came from is
			
 
				+    transient and cannot be rebuilt here (#2591).
			
 
				+    """
			
 
				+    from backend.app.api.routes.settings import get_setting
			
 
				+
			
 
				+    setting = await get_setting(db, "spoolman_enabled")
			
 
				+    return bool(setting) and setting.lower() == "true"
			
 
				+
			
 
				+
			
 
				 @router.post("/{archive_id}/rescan", response_model=ArchiveResponse)
			
 
				 async def rescan_archive(
			
 
				     archive_id: int,
			
@@ -1817,6 +1904,10 @@ async def rescan_archive(
 
				             if untracked_grams > 0 and default_cost_per_kg > 0:
			
 
				                 total_cost += (untracked_grams / 1000.0) * default_cost_per_kg
			
 
				             archive.cost = float(Decimal(str(total_cost)).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))
			
 
				+        elif await _spoolman_owns_cost(db) and archive.cost is not None:
			
 
				+            # Keep what completion priced from the linked spools. A rescan
			
 
				+            # re-reads the 3MF's metadata; it learns nothing about spools.
			
 
				+            pass
			
 
				         else:
			
 
				             primary_type = archive.filament_type.split(",")[0].strip()
			
 
				             filament_result = await db.execute(select(Filament).where(Filament.type == primary_type).limit(1))
			
@@ -1876,7 +1967,10 @@ async def recalculate_all_costs(
 
				         if row[0] is not None and row[1] is not None and row[1] > 0
			
 
				     }
			
 
				 
			
 
				+    spoolman_owns = await _spoolman_owns_cost(db)
			
 
				+
			
 
				     updated = 0
			
 
				+    preserved = 0
			
 
				     for archive in archives:
			
 
				         usage = cost_map.get(archive.id)
			
 
				         if usage is not None:
			
@@ -1898,6 +1992,11 @@ async def recalculate_all_costs(
 
				             fallback_cost = usage_result.scalar()
			
 
				             if fallback_cost is not None and fallback_cost > 0:
			
 
				                 new_cost = round(fallback_cost, 2)
			
 
				+            elif spoolman_owns and archive.cost is not None:
			
 
				+                # Priced from the linked Spoolman spools at completion; there is
			
 
				+                # nothing better to recompute it from here (#2591).
			
 
				+                new_cost = None
			
 
				+                preserved += 1
			
 
				             elif archive.filament_used_grams and archive.filament_type:
			
 
				                 primary_type = archive.filament_type.split(",")[0].strip()
			
 
				                 cost_per_kg = filaments.get(primary_type, default_cost_per_kg)
			
@@ -1909,7 +2008,10 @@ async def recalculate_all_costs(
 
				             updated += 1
			
 
				 
			
 
				     await db.commit()
			
 
				-    return {"message": f"Recalculated costs for {updated} archives", "updated": updated}
			
 
				+    message = f"Recalculated costs for {updated} archives"
			
 
				+    if preserved:
			
 
				+        message += f"; kept {preserved} priced from Spoolman"
			
 
				+    return {"message": message, "updated": updated, "preserved": preserved}
			
 
				 
			
 
				 
			
 
				 @router.post("/rescan-all")
			
@@ -2246,6 +2348,203 @@ async def get_thumbnail(
 
				     )
			
 
				 
			
 
				 
			
 
				+@router.get("/{archive_id}/printer-media")
			
 
				+async def get_archive_printer_media(
			
 
				+    archive_id: int,
			
 
				+    auth_result: tuple[User | None, bool] = Depends(
			
 
				+        require_ownership_permission(
			
 
				+            Permission.ARCHIVES_READ_ALL,
			
 
				+            Permission.ARCHIVES_READ_OWN,
			
 
				+        )
			
 
				+    ),
			
 
				+    can_list_printer_files: bool = Depends(probe_permissions_if_auth_enabled(Permission.PRINTERS_FILES)),
			
 
				+    api_key: APIKey | None = Depends(current_api_key_if_present),
			
 
				+):
			
 
				+    """Find downloadable timelapse and `/ipcam` files for one print.
			
 
				+
			
 
				+    Local attached timelapses are returned without touching the printer.
			
 
				+    Printer directories are listed only when the caller also has
			
 
				+    ``printers:files``; otherwise the local result is returned with a warning.
			
 
				+    Files are downloaded only after the user explicitly selects them in the UI.
			
 
				+    """
			
 
				+
			
 
				+    user, can_read_all = auth_result
			
 
				+    async with database.async_session() as db:
			
 
				+        archive = _ensure_archive_visible(await ArchiveService(db).get_archive(archive_id), user, can_read_all)
			
 
				+        printer = None
			
 
				+        claimed_timelapse_stems: set[str] = set()
			
 
				+        if archive.printer_id is not None:
			
 
				+            printer = (await db.execute(select(Printer).where(Printer.id == archive.printer_id))).scalar_one_or_none()
			
 
				+            if printer is not None and archive.timelapse_path is None:
			
 
				+                claimed_timelapse_stems = await _claimed_timelapse_stems(db, archive.printer_id, archive_id)
			
 
				+
			
 
				+    local_timelapse = None
			
 
				+    if archive.timelapse_path:
			
 
				+        local_path = settings.base_dir / archive.timelapse_path
			
 
				+        if await asyncio.to_thread(local_path.is_file):
			
 
				+            local_timelapse = {
			
 
				+                "name": local_path.name,
			
 
				+                "size": (await asyncio.to_thread(local_path.stat)).st_size,
			
 
				+            }
			
 
				+
			
 
				+    response = {
			
 
				+        "archive_id": archive.id,
			
 
				+        "printer_id": archive.printer_id,
			
 
				+        "local_timelapse": local_timelapse,
			
 
				+        "remote_files": [],
			
 
				+        "warnings": [],
			
 
				+    }
			
 
				+    if archive.printer_id is None or archive.started_at is None:
			
 
				+        return response
			
 
				+    if not can_list_printer_files:
			
 
				+        response["warnings"].append("printer_files_forbidden")
			
 
				+        return response
			
 
				+
			
 
				+    if printer is None:
			
 
				+        response["warnings"].append("printer_missing")
			
 
				+        return response
			
 
				+    if api_key is not None:
			
 
				+        check_printer_access(api_key, printer.id)
			
 
				+
			
 
				+    if ftps_handshake_blocked(printer.ip_address):
			
 
				+        if local_timelapse is None:
			
 
				+            response["warnings"].append("timelapse_unavailable")
			
 
				+        response["warnings"].append("ipcam_unavailable")
			
 
				+        return response
			
 
				+
			
 
				+    remote_files: list[dict] = []
			
 
				+
			
 
				+    # If no copy was attached to the archive, offer the matching printer-side
			
 
				+    # timelapse without mutating the archive or deleting anything from the SD.
			
 
				+    if local_timelapse is None:
			
 
				+        videos: list[dict] = []
			
 
				+        any_timelapse_directory_available = False
			
 
				+        for timelapse_dir in ("/timelapse", "/timelapse/video", "/record", "/recording"):
			
 
				+            if ftps_handshake_blocked(printer.ip_address):
			
 
				+                break
			
 
				+            listing = await list_files_result_async(
			
 
				+                printer.ip_address,
			
 
				+                printer.access_code,
			
 
				+                timelapse_dir,
			
 
				+                timeout=_PRINTER_MEDIA_LIST_TIMEOUT_SECONDS,
			
 
				+                printer_model=printer.model,
			
 
				+            )
			
 
				+            any_timelapse_directory_available |= listing.available
			
 
				+            candidates = [
			
 
				+                file
			
 
				+                for file in listing.files
			
 
				+                if not file.get("is_directory") and str(file.get("name") or "").lower().endswith(VIDEO_SUFFIXES)
			
 
				+            ]
			
 
				+            if candidates:
			
 
				+                videos = candidates
			
 
				+                break
			
 
				+        if not any_timelapse_directory_available:
			
 
				+            response["warnings"].append("timelapse_unavailable")
			
 
				+        if videos:
			
 
				+            baseline = set(archive.timelapse_baseline or [])
			
 
				+            eligible = [
			
 
				+                file
			
 
				+                for file in videos
			
 
				+                if str(file.get("name") or "") not in baseline
			
 
				+                and Path(str(file.get("name") or "")).stem not in claimed_timelapse_stems
			
 
				+            ]
			
 
				+            if archive.timelapse_baseline is not None:
			
 
				+                candidate = eligible[0] if len(eligible) == 1 else None
			
 
				+            else:
			
 
				+                candidate, _ = _match_timelapse_by_timestamp(eligible, archive.started_at)
			
 
				+            if candidate is not None:
			
 
				+                remote_files.append(
			
 
				+                    {
			
 
				+                        "name": candidate.get("name"),
			
 
				+                        "path": candidate.get("path"),
			
 
				+                        "size": candidate.get("size") or 0,
			
 
				+                        "mtime": candidate.get("mtime"),
			
 
				+                        "kind": "timelapse",
			
 
				+                    }
			
 
				+                )
			
 
				+
			
 
				+    if ftps_handshake_blocked(printer.ip_address):
			
 
				+        response["warnings"].append("ipcam_unavailable")
			
 
				+        response["remote_files"] = remote_files
			
 
				+        return response
			
 
				+
			
 
				+    ipcam_listing = await list_files_result_async(
			
 
				+        printer.ip_address,
			
 
				+        printer.access_code,
			
 
				+        "/ipcam",
			
 
				+        timeout=_PRINTER_MEDIA_LIST_TIMEOUT_SECONDS,
			
 
				+        printer_model=printer.model,
			
 
				+    )
			
 
				+    if ipcam_listing.available:
			
 
				+        for file in match_ipcam_chunks(ipcam_listing.files, archive.started_at, archive.completed_at):
			
 
				+            remote_files.append(
			
 
				+                {
			
 
				+                    "name": file.get("name"),
			
 
				+                    "path": file.get("path") or f"/ipcam/{file.get('name')}",
			
 
				+                    "size": file.get("size") or 0,
			
 
				+                    "mtime": file.get("mtime"),
			
 
				+                    "kind": "ipcam",
			
 
				+                }
			
 
				+            )
			
 
				+    else:
			
 
				+        response["warnings"].append("ipcam_unavailable")
			
 
				+
			
 
				+    response["remote_files"] = remote_files
			
 
				+    return response
			
 
				+
			
 
				+
			
 
				+@router.post("/{archive_id}/media-download-token")
			
 
				+async def create_archive_media_download_token(
			
 
				+    archive_id: int,
			
 
				+    auth_result: tuple[User | None, bool] = Depends(
			
 
				+        require_ownership_permission(Permission.ARCHIVES_READ_ALL, Permission.ARCHIVES_READ_OWN)
			
 
				+    ),
			
 
				+):
			
 
				+    """Mint a single-use token bound to an archive's attached timelapse."""
			
 
				+
			
 
				+    from backend.app.core.auth import create_slicer_download_token
			
 
				+
			
 
				+    user, can_read_all = auth_result
			
 
				+    async with database.async_session() as db:
			
 
				+        archive = _ensure_archive_visible(await ArchiveService(db).get_archive(archive_id), user, can_read_all)
			
 
				+    if not archive.timelapse_path:
			
 
				+        raise HTTPException(404, "Timelapse not found")
			
 
				+    timelapse_path = settings.base_dir / archive.timelapse_path
			
 
				+    if not await asyncio.to_thread(timelapse_path.is_file):
			
 
				+        raise HTTPException(404, "Timelapse file not found")
			
 
				+    return {
			
 
				+        "token": await create_slicer_download_token("archive-timelapse", archive_id),
			
 
				+        "filename": timelapse_path.name,
			
 
				+    }
			
 
				+
			
 
				+
			
 
				+@router.get("/{archive_id}/media/dl/{token}/{filename}")
			
 
				+async def download_archive_media_with_token(
			
 
				+    archive_id: int,
			
 
				+    token: str,
			
 
				+    filename: str,
			
 
				+):
			
 
				+    """Consume a resource-bound token and stream an attached timelapse."""
			
 
				+
			
 
				+    from backend.app.core.auth import verify_slicer_download_token
			
 
				+
			
 
				+    if not await verify_slicer_download_token(token, "archive-timelapse", archive_id):
			
 
				+        return download_error_response(403, "This download link has already been used or has expired.")
			
 
				+    async with database.async_session() as db:
			
 
				+        archive = await ArchiveService(db).get_archive(archive_id)
			
 
				+    if not archive or not archive.timelapse_path:
			
 
				+        return download_error_response(404, "This print has no attached timelapse.")
			
 
				+    timelapse_path = settings.base_dir / archive.timelapse_path
			
 
				+    if not await asyncio.to_thread(timelapse_path.is_file):
			
 
				+        return download_error_response(404, "The attached timelapse is no longer on disk.")
			
 
				+    safe_filename = safe_download_filename(filename, fallback=timelapse_path.name)
			
 
				+    return FileResponse(
			
 
				+        path=timelapse_path,
			
 
				+        filename=safe_filename,
			
 
				+        headers={"Content-Disposition": build_content_disposition(safe_filename)},
			
 
				+    )
			
 
				+
			
 
				+
			
 
				 @router.get("/{archive_id}/timelapse")
			
 
				 async def get_timelapse(
			
 
				     archive_id: int,
			
@@ -2523,6 +2822,7 @@ async def scan_timelapse(
 
				             max_retries=ftp_retry_count,
			
 
				             retry_delay=ftp_retry_delay,
			
 
				             operation_name=f"Download timelapse {matching_file['name']}",
			
 
				+            cooloff_ip=printer.ip_address,
			
 
				         )
			
 
				     else:
			
 
				         timelapse_data = await download_file_bytes_async(
			
@@ -2645,6 +2945,7 @@ async def select_timelapse(
 
				             max_retries=ftp_retry_count,
			
 
				             retry_delay=ftp_retry_delay,
			
 
				             operation_name=f"Download timelapse {filename}",
			
 
				+            cooloff_ip=printer.ip_address,
			
 
				         )
			
 
				     else:
			
 
				         timelapse_data = await download_file_bytes_async(
			
@@ -3222,8 +3523,10 @@ async def get_archive_capabilities(
 
				         with zipfile.ZipFile(file_path, "r") as zf:
			
 
				             names = zf.namelist()
			
 
				 
			
 
				-            # Check for G-code in the sliced file
			
 
				-            has_gcode = any(n.startswith("Metadata/") and n.endswith(".gcode") for n in names)
			
 
				+            # Check for G-code in the sliced file. Shared with the library's
			
 
				+            # file-type classification so the card's badge and what the File
			
 
				+            # Manager makes of the same file cannot disagree (#2993).
			
 
				+            has_gcode = names_carry_gcode(names)
			
 
				 
			
 
				             # Check for 3D model in sliced file (fallback if no source)
			
 
				             if not has_model:
			
--- a/backend/app/api/routes/camera.py
+++ b/backend/app/api/routes/camera.py
@@ -22,12 +22,12 @@ from backend.app.core.auth import (
 
				     create_camera_stream_token,
			
 
				 )
			
 
				 from backend.app.core.database import get_db
			
 
				-from backend.app.core.logging_filters import redact_url_credentials
			
 
				 from backend.app.core.permissions import Permission
			
 
				 from backend.app.models.printer import Printer
			
 
				 from backend.app.models.user import User
			
 
				 from backend.app.services.camera import (
			
 
				     capture_camera_frame,
			
 
				+    close_tls_proxy,
			
 
				     create_tls_proxy,
			
 
				     generate_chamber_image_stream,
			
 
				     get_camera_port,
			
@@ -45,6 +45,7 @@ from backend.app.services.camera_fanout import (
 
				     shutdown_broadcaster,
			
 
				 )
			
 
				 from backend.app.services.camera_profiles import get_camera_profile
			
 
				+from backend.app.utils.ffmpeg_output import summarize_ffmpeg_stderr
			
 
				 
			
 
				 logger = logging.getLogger(__name__)
			
 
				 router = APIRouter(prefix="/printers", tags=["camera"])
			
@@ -407,37 +408,11 @@ async def _terminate_ffmpeg(process: asyncio.subprocess.Process, stream_id: str
 
				         _spawned_ffmpeg_pids.pop(process.pid, None)
			
 
				 
			
 
				 
			
 
				-def _summarize_ffmpeg_stderr(text: str | None) -> str:
			
 
				-    """Strip ffmpeg's boilerplate banner and keep only actionable lines.
			
 
				-
			
 
				-    ffmpeg prints ~20 lines of version/build/configuration/lib headers before
			
 
				-    any actual error message. Logging the full banner on every retry floods
			
 
				-    the log (hundreds of lines per failed stream). This filter drops the
			
 
				-    banner and caps output at the last 10 meaningful lines.
			
 
				-
			
 
				-    Credentials are masked here rather than at each ``logger`` call because
			
 
				-    this is the one funnel every stderr log in this module passes through.
			
 
				-    ffmpeg echoes the RTSP input URL back in its ``Input #0`` line, which
			
 
				-    carries the printer access code.
			
 
				-    """
			
 
				-    if not text:
			
 
				-        return ""
			
 
				-    text = redact_url_credentials(text) or ""
			
 
				-    banner_prefixes = (
			
 
				-        "ffmpeg version ",
			
 
				-        "  built with ",
			
 
				-        "  configuration:",
			
 
				-        "  libavutil ",
			
 
				-        "  libavcodec ",
			
 
				-        "  libavformat ",
			
 
				-        "  libavdevice ",
			
 
				-        "  libavfilter ",
			
 
				-        "  libswscale ",
			
 
				-        "  libswresample ",
			
 
				-        "  libpostproc ",
			
 
				-    )
			
 
				-    meaningful = [ln for ln in text.splitlines() if ln.strip() and not ln.startswith(banner_prefixes)]
			
 
				-    return "\n".join(meaningful[-10:])
			
 
				+# The banner-stripping summariser moved to backend.app.utils.ffmpeg_output so
			
 
				+# the seven other places that log ffmpeg stderr could stop truncating it from
			
 
				+# the front (#2968). Imported under the private name this module has always
			
 
				+# used: _FfmpegStderrTail and the tests both reach for it by that name.
			
 
				+_summarize_ffmpeg_stderr = summarize_ffmpeg_stderr
			
 
				 
			
 
				 
			
 
				 class _FfmpegStderrTail:
			
@@ -851,8 +826,7 @@ async def generate_rtsp_mjpeg_stream(
 
				             await stderr_tail.aclose()
			
 
				 
			
 
				         # Shut down the TLS proxy
			
 
				-        proxy_server.close()
			
 
				-        await proxy_server.wait_closed()
			
 
				+        await close_tls_proxy(proxy_server)
			
 
				 
			
 
				 
			
 
				 @router.post("/camera/stream-token")
			
--- a/backend/app/api/routes/inventory.py
+++ b/backend/app/api/routes/inventory.py
@@ -26,6 +26,7 @@ from backend.app.models.settings import Settings
 
				 from backend.app.models.spool import Spool
			
 
				 from backend.app.models.spool_assignment import SpoolAssignment
			
 
				 from backend.app.models.spool_catalog import SpoolCatalogEntry
			
 
				+from backend.app.models.spool_filament_preset import SpoolFilamentPreset
			
 
				 from backend.app.models.spool_k_profile import SpoolKProfile
			
 
				 from backend.app.models.user import User
			
 
				 from backend.app.schemas.location import LocationCreate, LocationResponse, LocationUpdate
			
@@ -34,6 +35,8 @@ from backend.app.schemas.spool import (
 
				     SpoolAssignmentResponse,
			
 
				     SpoolBulkCreate,
			
 
				     SpoolCreate,
			
 
				+    SpoolFilamentPresetBase,
			
 
				+    SpoolFilamentPresetResponse,
			
 
				     SpoolKProfileBase,
			
 
				     SpoolKProfileResponse,
			
 
				     SpoolResponse,
			
@@ -53,6 +56,7 @@ from backend.app.services.location_service import (
 
				     rename_location as rename_location_record,
			
 
				 )
			
 
				 from backend.app.services.slicer_filament_resolver import resolve_slicer_filament
			
 
				+from backend.app.services.slot_nozzle import resolve_slot_nozzle
			
 
				 from backend.app.services.spool_csv import (
			
 
				     MAX_CSV_IMPORT_BYTES,
			
 
				     ImportPreview,
			
@@ -60,13 +64,15 @@ from backend.app.services.spool_csv import (
 
				     parse_and_validate,
			
 
				     serialize,
			
 
				 )
			
 
				+from backend.app.services.spool_filament_preset import resolve_spool_preset
			
 
				 from backend.app.services.spoolman import SpoolmanClient, get_spoolman_client, init_spoolman_client
			
 
				 from backend.app.utils.filament_ids import (
			
 
				     GENERIC_FILAMENT_IDS,
			
 
				-    MATERIAL_TEMPS,
			
 
				     filament_id_to_setting_id,
			
 
				     normalize_slicer_filament,
			
 
				 )
			
 
				+from backend.app.utils.filament_types import is_material_name, nozzle_temp_range, printer_filament_type
			
 
				+from backend.app.utils.natural_sort import natural_sort_key
			
 
				 from backend.app.utils.tag_normalization import normalize_tag_uid, normalize_tray_uuid
			
 
				 
			
 
				 logger = logging.getLogger(__name__)
			
@@ -114,18 +120,40 @@ async def apply_spool_to_slot_via_mqtt(
 
				 
			
 
				     state = printer_manager.get_status(printer_id)
			
 
				 
			
 
				-    tray_type = spool.material
			
 
				-    tray_sub_brands = (
			
 
				-        f"{spool.brand} {spool.material} {spool.subtype}".strip()
			
 
				-        if spool.brand
			
 
				-        else f"{spool.material} {spool.subtype}"
			
 
				-        if spool.subtype
			
 
				-        else spool.material
			
 
				-    )
			
 
				+    # The slot carries the material type; the product line the material column
			
 
				+    # may actually hold ("PLA+", "HTPLA") stays in tray_sub_brands below, which
			
 
				+    # is where Bambu puts it too (issue #2902).
			
 
				+    tray_type = printer_filament_type(spool.material)
			
 
				+    # Join only the parts that exist. The previous shape interpolated
			
 
				+    # `spool.subtype` into the branded string without checking it, so a spool
			
 
				+    # with a brand and no subtype went to the printer as
			
 
				+    # "Sunlu PLA Matte None" -- the string "None", on the wire (#2987). The
			
 
				+    # unbranded branch guarded subtype; the branded one did not.
			
 
				+    tray_sub_brands = " ".join(p for p in (spool.brand, spool.material, spool.subtype) if p) or spool.material
			
 
				     tray_color = spool.rgba or "FFFFFFFF"
			
 
				 
			
 
				     _generic_id_values = _GENERIC_ID_VALUES
			
 
				-    _known_materials = set(MATERIAL_TEMPS.keys()) | set(GENERIC_FILAMENT_IDS.keys())
			
 
				+
			
 
				+    # Which nozzle this slot feeds, and how wide it is. One resolution shared
			
 
				+    # with every other path that configures a slot (see services.slot_nozzle),
			
 
				+    # and used twice below -- for the spool's per-model preset override and for
			
 
				+    # its K profile -- so the two lookups cannot answer for different nozzles.
			
 
				+    slot_nozzle = resolve_slot_nozzle(state, ams_id, tray_id, printer_manager.get_model(printer_id))
			
 
				+    nozzle_diameter = slot_nozzle.diameter
			
 
				+
			
 
				+    # A cloud or Orca preset is bound to a printer MODEL ("@BBL X1C"), so the
			
 
				+    # spool's single slicer_filament stops being right the moment the same
			
 
				+    # spool is used on a second model. resolve_spool_preset returns the
			
 
				+    # spool's own value unless the user has set an override for this model,
			
 
				+    # so a spool nobody has configured behaves exactly as it did before.
			
 
				+    slot_slicer_filament, slot_slicer_filament_name = await resolve_spool_preset(
			
 
				+        db,
			
 
				+        spool_id=spool.id,
			
 
				+        printer_model=printer_manager.get_model(printer_id),
			
 
				+        nozzle_diameter=nozzle_diameter,
			
 
				+        fallback_filament=spool.slicer_filament,
			
 
				+        fallback_name=spool.slicer_filament_name,
			
 
				+    )
			
 
				 
			
 
				     # slicer_filament → (tray_info_idx, setting_id) resolution is shared with
			
 
				     # the Spoolman-mode route via this helper (#1713). The helper handles
			
@@ -133,15 +161,20 @@ async def apply_spool_to_slot_via_mqtt(
 
				     # the builtin-name realignment, AND the defensive PFUS/PFCN/material-name
			
 
				     # sanitization. When it returns an empty tray_info_idx the local
			
 
				     # current-tray-state + generic-material fallback below rescues the slot.
			
 
				-    tray_info_idx, setting_id, sub_brand_override = await resolve_slicer_filament(
			
 
				+    tray_info_idx, setting_id, sub_brand_override, type_override = await resolve_slicer_filament(
			
 
				         db=db,
			
 
				         current_user=current_user,
			
 
				-        slicer_filament=spool.slicer_filament,
			
 
				-        slicer_filament_name=spool.slicer_filament_name,
			
 
				+        slicer_filament=slot_slicer_filament,
			
 
				+        slicer_filament_name=slot_slicer_filament_name,
			
 
				         material=spool.material,
			
 
				     )
			
 
				     if sub_brand_override:
			
 
				         tray_sub_brands = sub_brand_override
			
 
				+    # A preset says what its material is; the reduction above only infers it
			
 
				+    # from whatever wording the spool's material column happens to carry. When
			
 
				+    # the spool has a preset, its answer wins (issue #2902, @doncaruana).
			
 
				+    if type_override:
			
 
				+        tray_type = printer_filament_type(type_override)
			
 
				 
			
 
				     if not tray_info_idx:
			
 
				         if (
			
@@ -149,16 +182,25 @@ async def apply_spool_to_slot_via_mqtt(
 
				             and current_tray_info_idx not in _generic_id_values
			
 
				             and not current_tray_info_idx.startswith("PFUS")
			
 
				             and not current_tray_info_idx.startswith("PFCN")
			
 
				-            and current_tray_info_idx.upper() not in _known_materials
			
 
				+            # Shares the resolver's reading of what counts as a material
			
 
				+            # name, product lines included: a slot written by a Bambuddy from
			
 
				+            # before #2902 can be holding "PLA+" in this field, and reusing
			
 
				+            # that would carry the bad id forward instead of replacing it.
			
 
				+            and not is_material_name(current_tray_info_idx)
			
 
				             and current_tray_type
			
 
				             and current_tray_type.upper() == tray_type.upper()
			
 
				         ):
			
 
				             tray_info_idx = current_tray_info_idx
			
 
				         elif tray_type:
			
 
				-            material = tray_type.upper().strip()
			
 
				+            # The spool's own wording is tried first and the reduced type only
			
 
				+            # as a further fallback, so a material that already resolves keeps
			
 
				+            # resolving to the same id: "PETG HF" has its own generic preset
			
 
				+            # (GFG96) that reducing it to "PETG" would trade away for GFG99.
			
 
				+            material = (spool.material or "").upper().strip()
			
 
				             generic = (
			
 
				                 GENERIC_FILAMENT_IDS.get(material)
			
 
				                 or GENERIC_FILAMENT_IDS.get(material.split("-")[0].split(" ")[0])
			
 
				+                or GENERIC_FILAMENT_IDS.get(tray_type.upper())
			
 
				                 or ""
			
 
				             )
			
 
				             if generic:
			
@@ -172,24 +214,16 @@ async def apply_spool_to_slot_via_mqtt(
 
				     if tray_info_idx and not setting_id:
			
 
				         setting_id = filament_id_to_setting_id(tray_info_idx)
			
 
				 
			
 
				-    temp_min, temp_max = MATERIAL_TEMPS.get((spool.material or "").upper(), (200, 240))
			
 
				+    # Same order as the generic-id lookup above: the spool's own wording wins,
			
 
				+    # the reduced type rescues what it does not cover. Without the second
			
 
				+    # lookup a PLA+ spool took the 200/240 catch-all instead of PLA's 190/230.
			
 
				+    temp_min, temp_max = nozzle_temp_range(spool.material, tray_type)
			
 
				     if spool.nozzle_temp_min is not None:
			
 
				         temp_min = spool.nozzle_temp_min
			
 
				     if spool.nozzle_temp_max is not None:
			
 
				         temp_max = spool.nozzle_temp_max
			
 
				 
			
 
				-    nozzle_diameter = "0.4"
			
 
				-    if state and state.nozzles:
			
 
				-        nd = state.nozzles[0].nozzle_diameter
			
 
				-        if nd:
			
 
				-            nozzle_diameter = nd
			
 
				-
			
 
				-    slot_extruder = None
			
 
				-    if state and state.ams_extruder_map:
			
 
				-        if ams_id == 255:
			
 
				-            slot_extruder = 1 - tray_id  # ext-L (tray 0) → extruder 1, ext-R (tray 1) → extruder 0
			
 
				-        else:
			
 
				-            slot_extruder = state.ams_extruder_map.get(str(ams_id))
			
 
				+    slot_extruder = slot_nozzle.extruder
			
 
				 
			
 
				     # Prefer exact extruder match, fall back to extruder-agnostic kp for the
			
 
				     # same nozzle. Hard-skipping on mismatch silently drops valid stored
			
@@ -199,6 +233,12 @@ async def apply_spool_to_slot_via_mqtt(
 
				     for kp in spool.k_profiles:
			
 
				         if kp.printer_id != printer_id or kp.nozzle_diameter != nozzle_diameter:
			
 
				             continue
			
 
				+        # A profile measured on a high-flow nozzle is not a fact about a
			
 
				+        # standard one. Rows with no stored flow -- everything saved before
			
 
				+        # this, and everything from a printer whose table declares none --
			
 
				+        # still match, see SlotNozzle.flow_matches.
			
 
				+        if not slot_nozzle.flow_matches(kp.nozzle_type):
			
 
				+            continue
			
 
				         if slot_extruder is not None and kp.extruder is not None and kp.extruder == slot_extruder:
			
 
				             exact_kp = kp
			
 
				             break
			
@@ -607,8 +647,10 @@ async def list_locations(
 
				 ):
			
 
				     """List all storage locations with spool counts."""
			
 
				     settings = await _load_settings_map(db)
			
 
				-    result = await db.execute(select(Location).order_by(Location.name))
			
 
				-    locations = list(result.scalars().all())
			
 
				+    result = await db.execute(select(Location))
			
 
				+    # Sorted in Python, not SQL: "Drybox 2" belongs before "Drybox 10", and
			
 
				+    # ORDER BY name gives the opposite (plain lexicographic) order.
			
 
				+    locations = sorted(result.scalars().all(), key=lambda loc: natural_sort_key(loc.name))
			
 
				     counts = await _spool_counts_for_locations(db, locations, settings)
			
 
				     return [_location_to_response(loc, counts.get(loc.id, 0)) for loc in locations]
			
 
				 
			
@@ -744,6 +786,21 @@ async def get_color_name_map(
 
				     Normalized to lowercase 6-char hex without '#'. When multiple catalog entries
			
 
				     share the same hex (different materials or manufacturers), Bambu Lab wins,
			
 
				     then default entries, then the first encountered.
			
 
				+
			
 
				+    ``by_material`` carries the names that collapsing loses. A hex is not one
			
 
				+    colour in Bambu's range: #FFFFFF is Jade White in PLA Basic, Ivory White in
			
 
				+    PLA Matte and plain White in six more, and #000000 is Black except in PLA
			
 
				+    Matte where it is Charcoal. A caller that knows the material — an AMS slot
			
 
				+    knows it as ``tray_sub_brands`` — looks up ``"<material>|<hex>"`` there
			
 
				+    first and falls back to ``colors`` (#2875).
			
 
				+
			
 
				+    An entry is included only when it recovers a name the *same manufacturer's*
			
 
				+    own range lost. Two conditions, both load-bearing: a name equal to the
			
 
				+    collapsed one is pure weight, and a name from a different manufacturer is
			
 
				+    not a recovery at all — it would put Prusament's "Pristine White" on every
			
 
				+    generic white PLA slot in place of Bambu's "Jade White", trading one
			
 
				+    arbitrary answer for another. What survives is the handful of cases this
			
 
				+    exists for.
			
 
				     """
			
 
				     result = await db.execute(
			
 
				         select(
			
@@ -751,24 +808,43 @@ async def get_color_name_map(
 
				             ColorCatalogEntry.color_name,
			
 
				             ColorCatalogEntry.manufacturer,
			
 
				             ColorCatalogEntry.is_default,
			
 
				+            ColorCatalogEntry.material,
			
 
				         )
			
 
				     )
			
 
				-    mapping: dict[str, tuple[str, int]] = {}  # hex → (name, priority); higher priority wins
			
 
				-    for hex_color, color_name, manufacturer, is_default in result.all():
			
 
				+    # hex → (name, priority, manufacturer); higher priority wins, first on a tie
			
 
				+    mapping: dict[str, tuple[str, int, str]] = {}
			
 
				+    by_material: dict[str, tuple[str, int, str]] = {}  # "material|hex" → same
			
 
				+    for hex_color, color_name, manufacturer, is_default, material in result.all():
			
 
				         if not hex_color or not color_name:
			
 
				             continue
			
 
				         key = hex_color.lstrip("#").lower()[:6]
			
 
				         if len(key) != 6:
			
 
				             continue
			
 
				+        brand = (manufacturer or "").strip().lower()
			
 
				         priority = 0
			
 
				-        if manufacturer and manufacturer.strip().lower() == "bambu lab":
			
 
				+        if brand == "bambu lab":
			
 
				             priority += 2
			
 
				         if is_default:
			
 
				             priority += 1
			
 
				         existing = mapping.get(key)
			
 
				         if existing is None or priority > existing[1]:
			
 
				-            mapping[key] = (color_name, priority)
			
 
				-    return {"colors": {k: v[0] for k, v in mapping.items()}}
			
 
				+            mapping[key] = (color_name, priority, brand)
			
 
				+        material_key = (material or "").strip().lower()
			
 
				+        if material_key:
			
 
				+            # Split on the LAST separator when reading these back: a material is
			
 
				+            # free text and may itself contain a '|'.
			
 
				+            qualified = f"{material_key}|{key}"
			
 
				+            existing = by_material.get(qualified)
			
 
				+            if existing is None or priority > existing[1]:
			
 
				+                by_material[qualified] = (color_name, priority, brand)
			
 
				+
			
 
				+    colors = {k: v[0] for k, v in mapping.items()}
			
 
				+    qualified_colors = {}
			
 
				+    for qualified, (name, _, brand) in by_material.items():
			
 
				+        flat = mapping.get(qualified.rsplit("|", 1)[1])
			
 
				+        if flat and flat[0] != name and flat[2] == brand:
			
 
				+            qualified_colors[qualified] = name
			
 
				+    return {"colors": colors, "by_material": qualified_colors}
			
 
				 
			
 
				 
			
 
				 @router.post("/colors", response_model=ColorEntryResponse)
			
@@ -1611,6 +1687,73 @@ async def replace_k_profiles(
 
				     return new_profiles
			
 
				 
			
 
				 
			
 
				+@router.get("/spools/{spool_id}/filament-presets", response_model=list[SpoolFilamentPresetResponse])
			
 
				+async def list_filament_presets(
			
 
				+    spool_id: int,
			
 
				+    db: AsyncSession = Depends(get_db),
			
 
				+    _: User | None = RequirePermissionIfAuthEnabled(Permission.INVENTORY_READ),
			
 
				+):
			
 
				+    """List per-printer-model preset overrides for a spool.
			
 
				+
			
 
				+    A dedicated endpoint rather than a field on ``SpoolResponse``: the
			
 
				+    inventory list returns every spool the user owns, and only the spool form
			
 
				+    and the assign path ever need this list, one spool at a time.
			
 
				+    """
			
 
				+    result = await db.execute(select(SpoolFilamentPreset).where(SpoolFilamentPreset.spool_id == spool_id))
			
 
				+    return list(result.scalars().all())
			
 
				+
			
 
				+
			
 
				+@router.put("/spools/{spool_id}/filament-presets", response_model=list[SpoolFilamentPresetResponse])
			
 
				+async def replace_filament_presets(
			
 
				+    spool_id: int,
			
 
				+    presets: list[SpoolFilamentPresetBase],
			
 
				+    db: AsyncSession = Depends(get_db),
			
 
				+    _: User | None = RequirePermissionIfAuthEnabled(Permission.INVENTORY_UPDATE),
			
 
				+):
			
 
				+    """Replace all per-printer-model preset overrides for a spool.
			
 
				+
			
 
				+    Replace rather than merge, matching the K-profile endpoint next door: the
			
 
				+    spool form always holds the complete set, and an empty list is how the
			
 
				+    user clears every override back to the spool's own preset.
			
 
				+    """
			
 
				+    result = await db.execute(select(Spool).where(Spool.id == spool_id))
			
 
				+    if not result.scalar_one_or_none():
			
 
				+        raise HTTPException(404, "Spool not found")
			
 
				+
			
 
				+    # (model, diameter) is UNIQUE, so a payload that names one twice would
			
 
				+    # fail on flush with an IntegrityError the client cannot act on. Reject it
			
 
				+    # by name instead -- and reject it BEFORE deleting the existing rows, so a
			
 
				+    # bad request cannot wipe overrides it then fails to replace.
			
 
				+    seen: set[tuple[str, str]] = set()
			
 
				+    for p in presets:
			
 
				+        key = (p.printer_model, p.nozzle_diameter)
			
 
				+        if key in seen:
			
 
				+            raise HTTPException(
			
 
				+                422,
			
 
				+                f"Duplicate override for model {p.printer_model!r} nozzle {p.nozzle_diameter or 'any'!r}",
			
 
				+            )
			
 
				+        seen.add(key)
			
 
				+
			
 
				+    existing = await db.execute(select(SpoolFilamentPreset).where(SpoolFilamentPreset.spool_id == spool_id))
			
 
				+    for old in existing.scalars().all():
			
 
				+        await db.delete(old)
			
 
				+    # Land the deletes before the inserts: within one transaction SQLAlchemy is
			
 
				+    # free to order the INSERTs first, which trips the UNIQUE constraint
			
 
				+    # against rows this call is about to remove.
			
 
				+    await db.flush()
			
 
				+
			
 
				+    new_presets = []
			
 
				+    for p in presets:
			
 
				+        row = SpoolFilamentPreset(spool_id=spool_id, **p.model_dump())
			
 
				+        db.add(row)
			
 
				+        new_presets.append(row)
			
 
				+
			
 
				+    await db.commit()
			
 
				+    for row in new_presets:
			
 
				+        await db.refresh(row)
			
 
				+    return new_presets
			
 
				+
			
 
				+
			
 
				 # ── Spool Assignments ────────────────────────────────────────────────────────
			
 
				 
			
 
				 
			
--- a/backend/app/api/routes/labels.py
+++ b/backend/app/api/routes/labels.py
@@ -5,7 +5,8 @@ Two endpoints, one per inventory backend:
 
				 - ``POST /inventory/labels``  — local-DB spools
			
 
				 - ``POST /spoolman/labels``   — Spoolman-backed spools
			
 
				 
			
 
				-Both accept ``{spool_ids: [int], template: str}`` and return a PDF stream.
			
 
				+Both accept ``{spool_ids: [int], template: str, starting_position: int}`` and
			
 
				+return a PDF stream.
			
 
				 The QR code on each label deep-links to ``/inventory?spool=<id>`` so a phone
			
 
				 scan jumps straight back into Bambuddy at that spool's row.
			
 
				 """
			
@@ -18,17 +19,18 @@ from typing import Literal
 
				 
			
 
				 from fastapi import APIRouter, Depends, HTTPException, Request
			
 
				 from fastapi.responses import StreamingResponse
			
 
				-from pydantic import BaseModel, Field
			
 
				+from pydantic import BaseModel, Field, model_validator
			
 
				 from sqlalchemy import select
			
 
				 from sqlalchemy.ext.asyncio import AsyncSession
			
 
				 
			
 
				+from backend.app.api.routes._spoolman_helpers import parse_spoolman_multi_colors
			
 
				 from backend.app.api.routes.settings import get_setting
			
 
				 from backend.app.core.auth import RequirePermissionIfAuthEnabled
			
 
				 from backend.app.core.database import get_db
			
 
				 from backend.app.core.permissions import Permission
			
 
				 from backend.app.models.spool import Spool
			
 
				 from backend.app.models.user import User
			
 
				-from backend.app.services.label_renderer import LabelData, TemplateName, render_labels
			
 
				+from backend.app.services.label_renderer import LabelData, TemplateName, get_sheet_capacity, render_labels
			
 
				 from backend.app.services.spoolman import get_spoolman_client
			
 
				 from backend.app.utils.http import build_content_disposition
			
 
				 
			
@@ -63,6 +65,18 @@ class LabelRequest(BaseModel):
 
				     # Black-and-white thermal printers: drop the colour swatch (prints as a
			
 
				     # muddy grey block) and widen the text column instead (#1870).
			
 
				     monochrome: bool = False
			
 
				+    starting_position: int = Field(default=1, ge=1)
			
 
				+
			
 
				+    @model_validator(mode="after")
			
 
				+    def validate_starting_position(self) -> LabelRequest:
			
 
				+        capacity = get_sheet_capacity(self.template)
			
 
				+        if capacity is None:
			
 
				+            if self.starting_position != 1:
			
 
				+                raise ValueError("starting_position is only supported for sheet label templates")
			
 
				+            return self
			
 
				+        if self.starting_position > capacity:
			
 
				+            raise ValueError(f"starting_position must be between 1 and {capacity} for template {self.template}")
			
 
				+        return self
			
 
				 
			
 
				 
			
 
				 def _split_extra_colors(raw: str | None) -> list[str] | None:
			
@@ -114,12 +128,9 @@ def _spoolman_dict_to_label_data(s: dict, deeplink_base: str) -> LabelData:
 
				     color_hex = filament.get("color_hex")
			
 
				     rgba = color_hex.lstrip("#") if isinstance(color_hex, str) else None
			
 
				 
			
 
				-    multi_colors = filament.get("multi_color_hexes")
			
 
				-    extra: list[str] | None = None
			
 
				-    if isinstance(multi_colors, str) and multi_colors.strip():
			
 
				-        extra = [tok.strip().lstrip("#") for tok in multi_colors.split(",") if tok.strip()]
			
 
				-    elif isinstance(multi_colors, list):
			
 
				-        extra = [str(t).strip().lstrip("#") for t in multi_colors if str(t).strip()]
			
 
				+    # Shared with `_map_spoolman_spool`, so the swatch printed on a label and
			
 
				+    # the swatch drawn on an AMS slot card cannot read the same field two ways.
			
 
				+    extra: list[str] | None = parse_spoolman_multi_colors(filament) or None
			
 
				 
			
 
				     return LabelData(
			
 
				         spool_id=int(s.get("id", 0)),
			
@@ -173,7 +184,12 @@ async def render_local_inventory_labels(
 
				     deeplink_base = await _resolve_deeplink_base(request, db)
			
 
				     data_list = [_spool_to_label_data(s, deeplink_base) for s in ordered]
			
 
				 
			
 
				-    pdf = render_labels(body.template, data_list, monochrome=body.monochrome)
			
 
				+    pdf = render_labels(
			
 
				+        body.template,
			
 
				+        data_list,
			
 
				+        monochrome=body.monochrome,
			
 
				+        starting_position=body.starting_position,
			
 
				+    )
			
 
				     filename = f"bambuddy-labels-{body.template}.pdf"
			
 
				     return _stream_pdf(pdf, filename)
			
 
				 
			
@@ -217,6 +233,11 @@ async def render_spoolman_labels(
 
				     deeplink_base = await _resolve_deeplink_base(request, db)
			
 
				     data_list = [_spoolman_dict_to_label_data(by_id[sid], deeplink_base) for sid in body.spool_ids]
			
 
				 
			
 
				-    pdf = render_labels(body.template, data_list, monochrome=body.monochrome)
			
 
				+    pdf = render_labels(
			
 
				+        body.template,
			
 
				+        data_list,
			
 
				+        monochrome=body.monochrome,
			
 
				+        starting_position=body.starting_position,
			
 
				+    )
			
 
				     filename = f"bambuddy-labels-spoolman-{body.template}.pdf"
			
 
				     return _stream_pdf(pdf, filename)
			
--- a/backend/app/api/routes/library.py
+++ b/backend/app/api/routes/library.py
@@ -65,6 +65,7 @@ from backend.app.schemas.library import (
 
				 from backend.app.schemas.slicer import SliceRequest, SliceResponse
			
 
				 from backend.app.services.archive import ThreeMFParser
			
 
				 from backend.app.services.design_settings import (
			
 
				+    DesignOverride,
			
 
				     apply_design_overrides,
			
 
				     extract_design_process_overrides,
			
 
				     overrides_from_config,
			
@@ -72,7 +73,12 @@ from backend.app.services.design_settings import (
 
				 from backend.app.services.filament_requirements import annotate_rack_groups
			
 
				 from backend.app.services.plate_thumbnail import inject_plate_thumbnails_if_missing
			
 
				 from backend.app.services.process_overrides import apply_process_overrides
			
 
				-from backend.app.services.slice_output_check import missing_start_gcode_message, start_gcode_is_missing
			
 
				+from backend.app.services.slice_output_check import (
			
 
				+    missing_start_gcode_message,
			
 
				+    start_gcode_is_missing,
			
 
				+    unresolved_filament_message,
			
 
				+    unresolved_filament_slots,
			
 
				+)
			
 
				 from backend.app.services.stl_thumbnail import MIN_USABLE_STL_BYTES, generate_stl_thumbnail
			
 
				 from backend.app.utils.filename import (
			
 
				     MAX_FILENAME_BYTES,
			
@@ -82,6 +88,7 @@ from backend.app.utils.filename import (
 
				 )
			
 
				 from backend.app.utils.safe_path import PathTraversalError, assert_under, safe_join_under
			
 
				 from backend.app.utils.threemf_tools import (
			
 
				+    carries_gcode,
			
 
				     default_plate_gcode_name,
			
 
				     expand_to_project_slots,
			
 
				     extract_embedded_presets_from_3mf,
			
@@ -140,7 +147,7 @@ def get_library_files_dir() -> Path:
 
				     return files_dir
			
 
				 
			
 
				 
			
 
				-def classify_file_type(filename: str) -> str:
			
 
				+def classify_file_type(filename: str, file_path: Path | str | None = None) -> str:
			
 
				     """Return the canonical ``LibraryFile.file_type`` for *filename*.
			
 
				 
			
 
				     Compound extensions are preserved — a `.gcode.3mf` file (a sliced
			
@@ -152,12 +159,23 @@ def classify_file_type(filename: str) -> str:
 
				     downstream gates (gcode download, file-type filter, thumbnail
			
 
				     extraction) only need to handle one canonical name per file family.
			
 
				     Files with no extension classify as ``unknown``.
			
 
				+
			
 
				+    Pass ``file_path`` and a ``.3mf`` is judged on what the zip actually holds
			
 
				+    rather than on its name (#2993). The name is not evidence: a plate exported
			
 
				+    from Studio or a print dispatched through the cloud reaches the archive as
			
 
				+    ``Foo.3mf``, G-code and all, and downloading that and re-importing it used
			
 
				+    to land a fully printable file in the library as a source-only project. The
			
 
				+    file is not opened when the name already settles it, so the common case
			
 
				+    still costs nothing.
			
 
				     """
			
 
				     lower = filename.lower()
			
 
				     if lower.endswith(".gcode.3mf"):
			
 
				         return "gcode.3mf"
			
 
				     ext = os.path.splitext(lower)[1]
			
 
				-    return ext[1:] if ext else "unknown"
			
 
				+    file_type = ext[1:] if ext else "unknown"
			
 
				+    if file_type == "3mf" and file_path is not None and carries_gcode(file_path):
			
 
				+        return "gcode.3mf"
			
 
				+    return file_type
			
 
				 
			
 
				 
			
 
				 def get_library_thumbnails_dir() -> Path:
			
@@ -652,7 +670,7 @@ async def save_3mf_bytes_to_library(
 
				         is_external=is_external,
			
 
				         filename=filename,
			
 
				         file_path=_stored_file_path(file_path, is_external),
			
 
				-        file_type=classify_file_type(filename),
			
 
				+        file_type=classify_file_type(filename, file_path),
			
 
				         file_size=len(file_bytes),
			
 
				         file_hash=file_hash,
			
 
				         thumbnail_path=to_relative_path(thumbnail_path) if thumbnail_path else None,
			
@@ -1883,7 +1901,10 @@ async def scan_external_folder(
 
				             except OSError:
			
 
				                 continue
			
 
				 
			
 
				-            file_type = classify_file_type(filename)
			
 
				+            # The zip is opened for the thumbnail immediately below either way,
			
 
				+            # so judging a `.3mf` on its contents rather than its name (#2993)
			
 
				+            # costs this scan nothing.
			
 
				+            file_type = classify_file_type(filename, filepath)
			
 
				 
			
 
				             # Extract thumbnail for 3mf files (including .gcode.3mf sliced
			
 
				             # outputs — those are 3MF zips on disk and carry the same
			
@@ -2228,12 +2249,12 @@ async def upload_file(
 
				             validate_print_filename(filename)
			
 
				         except InvalidFilenameError as e:
			
 
				             raise HTTPException(status_code=400, detail=str(e)) from e
			
 
				-        ext = os.path.splitext(filename)[1].lower()
			
 
				-        # `file_type` is compound-aware (`gcode.3mf` for sliced outputs).
			
 
				-        # `ext` stays the trailing extension because the on-disk filename
			
 
				-        # uses it directly and the 3MF-parse branch below still gates on
			
 
				+        # `ext` stays the trailing extension because the on-disk filename uses
			
 
				+        # it directly and the 3MF-parse branch below still gates on
			
 
				         # `ext == ".3mf"`, which is correct for both `.3mf` and `.gcode.3mf`.
			
 
				-        file_type = classify_file_type(filename)
			
 
				+        # `file_type` is compound-aware and is decided further down, once the
			
 
				+        # bytes are on disk to be read.
			
 
				+        ext = os.path.splitext(filename)[1].lower()
			
 
				 
			
 
				         # Verify folder exists if specified
			
 
				         target_folder = None
			
@@ -2261,6 +2282,10 @@ async def upload_file(
 
				         with open(file_path, "wb") as f:
			
 
				             f.write(content)
			
 
				 
			
 
				+        # Now that the bytes are on disk the zip can settle what the name only
			
 
				+        # guessed at: a sliced 3MF uploaded as `Foo.3mf` is a sliced 3MF (#2993).
			
 
				+        file_type = classify_file_type(filename, file_path)
			
 
				+
			
 
				         # Calculate hash
			
 
				         file_hash = calculate_file_hash(file_path)
			
 
				 
			
@@ -2527,7 +2552,6 @@ async def extract_zip_file(
 
				                     # Extract file
			
 
				                     filename = os.path.basename(zip_path)
			
 
				                     ext = os.path.splitext(filename)[1].lower()
			
 
				-                    file_type = classify_file_type(filename)
			
 
				 
			
 
				                     # Generate unique filename for storage
			
 
				                     unique_filename = f"{uuid.uuid4().hex}{ext}"
			
@@ -2540,6 +2564,11 @@ async def extract_zip_file(
 
				                     with open(file_path, "wb") as f:
			
 
				                         f.write(file_content)
			
 
				 
			
 
				+                    # Classified once the bytes are on disk so a sliced 3MF
			
 
				+                    # named `Foo.3mf` inside the zip is recognised as sliced
			
 
				+                    # (#2993) rather than trusted to say so in its name.
			
 
				+                    file_type = classify_file_type(filename, file_path)
			
 
				+
			
 
				                     # Calculate hash
			
 
				                     file_hash = calculate_file_hash(file_path)
			
 
				 
			
@@ -3616,6 +3645,101 @@ def _patch_process_bed_type(process_json: str, bed_type: str) -> str:
 
				     return json.dumps(profile)
			
 
				 
			
 
				 
			
 
				+def _source_plate_colours(model_bytes: bytes) -> list[str]:
			
 
				+    """Per-slot colours the source 3MF was designed with, or ``[]``.
			
 
				+
			
 
				+    Read from ``project_settings.config`` rather than ``slice_info.config``:
			
 
				+    the latter records the colour the file was *last sliced* with, which for a
			
 
				+    source that never carried one is the slicer's own #00AE42 default — the
			
 
				+    exact value #2977 is about, so using it as a fallback would be circular.
			
 
				+    STL and mesh-only 3MF sources have no project settings and yield ``[]``.
			
 
				+    """
			
 
				+    from io import BytesIO
			
 
				+
			
 
				+    try:
			
 
				+        with zipfile.ZipFile(BytesIO(model_bytes), "r") as zf:
			
 
				+            return [str(f.get("color") or "") for f in extract_project_filaments_from_3mf(zf)]
			
 
				+    except (zipfile.BadZipFile, OSError, ValueError):
			
 
				+        return []
			
 
				+
			
 
				+
			
 
				+def _preset_default_colour(profile: dict) -> str:
			
 
				+    """A filament preset's own ``default_filament_colour``, or ``""``.
			
 
				+
			
 
				+    OrcaSlicer's third-party vendor profiles carry this; Bambu Studio's
			
 
				+    bundled BBL filament profiles carry it nowhere (checked across the whole
			
 
				+    shipped `resources/profiles/BBL/filament/` tree — zero occurrences), which
			
 
				+    is why it can only ever be one link in the chain and never the whole fix.
			
 
				+
			
 
				+    It is read here and rewritten as ``filament_colour`` because the CLI does
			
 
				+    not read it itself. Measured against a 02.08.02.61 sidecar: a profile
			
 
				+    carrying only ``default_filament_colour: ["#FF00FF"]`` still slices to
			
 
				+    ``filament_colour: ["#00AE42"]``. Bambu Studio consumes the default in the
			
 
				+    GUI when a project is created, not in ``--load-filaments``.
			
 
				+    """
			
 
				+    raw = profile.get("default_filament_colour")
			
 
				+    if isinstance(raw, list):
			
 
				+        raw = raw[0] if raw else None
			
 
				+    return raw.strip() if isinstance(raw, str) else ""
			
 
				+
			
 
				+
			
 
				+def _patch_filament_colours(
			
 
				+    filament_jsons: list[str],
			
 
				+    requested: list[str],
			
 
				+    model_bytes: bytes,
			
 
				+) -> list[str]:
			
 
				+    """Write ``filament_colour`` onto each resolved filament profile (#2977).
			
 
				+
			
 
				+    Neither slicer stores a colour on a filament *preset* — it is a per-project
			
 
				+    property their GUIs set from the plate — so a CLI slice with no colour
			
 
				+    supplied records Bambu Studio's compiled-in default for every slot. That
			
 
				+    default is `#00AE42`, which is why every internal-slicer output was green
			
 
				+    regardless of the filament picked, and why the print dialog's AMS mapping
			
 
				+    reported a colour mismatch against whatever was actually loaded.
			
 
				+
			
 
				+    Per slot, first non-empty of:
			
 
				+
			
 
				+    1. the caller's explicit colour (the SliceModal's per-slot swatch),
			
 
				+    2. the preset's own ``default_filament_colour``,
			
 
				+    3. the colour the source 3MF's plate was designed with.
			
 
				+
			
 
				+    All three empty means the slot is left untouched rather than being given a
			
 
				+    guess: the slicer's default is then still wrong, but it is at least the
			
 
				+    same wrong value the file would have had before this function existed.
			
 
				+
			
 
				+    Returns a new list; a profile that isn't parseable JSON is passed through
			
 
				+    unchanged, on the same reasoning as ``_patch_process_bed_type`` — a colour
			
 
				+    is not worth failing a slice that would otherwise succeed.
			
 
				+    """
			
 
				+    source_colours = _source_plate_colours(model_bytes) if filament_jsons else []
			
 
				+    patched: list[str] = []
			
 
				+    for i, raw in enumerate(filament_jsons):
			
 
				+        try:
			
 
				+            profile = json.loads(raw)
			
 
				+        except json.JSONDecodeError:
			
 
				+            logger.warning("Filament colour skipped for slot %d: profile is not valid JSON", i + 1)
			
 
				+            patched.append(raw)
			
 
				+            continue
			
 
				+        if not isinstance(profile, dict):
			
 
				+            patched.append(raw)
			
 
				+            continue
			
 
				+        colour = (
			
 
				+            (requested[i].strip() if i < len(requested) and requested[i] else "")
			
 
				+            or _preset_default_colour(profile)
			
 
				+            or (source_colours[i].strip() if i < len(source_colours) and source_colours[i] else "")
			
 
				+        )
			
 
				+        if not colour:
			
 
				+            patched.append(raw)
			
 
				+            continue
			
 
				+        # One-element array: the same shape the CLI uses for every other
			
 
				+        # per-filament field (`filament_type`, `filament_vendor`), and the
			
 
				+        # shape a `--load-filaments` profile is parsed as. A bare string is
			
 
				+        # accepted by the JSON parser but not by the config deserialiser.
			
 
				+        profile["filament_colour"] = [colour]
			
 
				+        patched.append(json.dumps(profile))
			
 
				+    return patched
			
 
				+
			
 
				+
			
 
				 # Support-related keys we lift from the source 3MF's project_settings.config
			
 
				 # into the picked process preset before `--load-settings` sees it (#1881).
			
 
				 # BambuStudio's shipped process presets ("0.20mm Standard @BBL H2D" etc.)
			
@@ -3632,7 +3756,31 @@ _SOURCE_PROCESS_SUPPORT_KEYS_TO_PRESERVE = (
 
				 )
			
 
				 
			
 
				 
			
 
				-def _patch_process_support_settings(process_json: str, source_3mf_bytes: bytes) -> str:
			
 
				+def _declined_source_keys(offered: list[DesignOverride], requested: list[str] | None) -> set[str]:
			
 
				+    """Settings the file offered and the caller left unticked (#2942).
			
 
				+
			
 
				+    The slice dialog lists what the designer changed and applies only the keys
			
 
				+    that are switched on, so the answer to "which of these does this slice
			
 
				+    want" is already in the request. This reads the other half of it — the
			
 
				+    ones that were on offer and turned down — which the support carry-over
			
 
				+    below must not put back.
			
 
				+
			
 
				+    ``requested`` of ``None`` is a caller that predates the per-key choice and
			
 
				+    so cannot have declined anything; an empty list is one that was shown the
			
 
				+    file's settings and took none. Collapsing those two into "nothing
			
 
				+    selected" is what made an empty panel indistinguishable from an old
			
 
				+    client, and only one of them means the user said no.
			
 
				+    """
			
 
				+    if requested is None:
			
 
				+        return set()
			
 
				+    return {override.key for override in offered} - set(requested)
			
 
				+
			
 
				+
			
 
				+def _patch_process_support_settings(
			
 
				+    process_json: str,
			
 
				+    source_3mf_bytes: bytes,
			
 
				+    declined: set[str] | frozenset[str] = frozenset(),
			
 
				+) -> str:
			
 
				     """Overlay the source 3MF's support configuration onto the process JSON.
			
 
				 
			
 
				     The carry is deliberately one-way: a source can switch supports *on*,
			
@@ -3645,6 +3793,13 @@ def _patch_process_support_settings(process_json: str, source_3mf_bytes: bytes)
 
				     with supports *on* is by definition a deliberate user preset, since
			
 
				     Bambu's shipped ones all ship them off.
			
 
				 
			
 
				+    ``declined`` names keys the caller offered the user as the file's own
			
 
				+    (#2622) and that the user left unticked, which this carry must then not
			
 
				+    reinstate behind their back (#2942). It is empty for a source that offers
			
 
				+    nothing — an OrcaSlicer export carries no ``different_settings_to_system``,
			
 
				+    so there is nothing to tick and #1881's blanket carry still applies — and
			
 
				+    for a client that predates the per-key ticks.
			
 
				+
			
 
				     Only fires on 3MF sources — STL / STEP don't carry `project_settings.
			
 
				     config`. Silently no-ops when the source doesn't have the config, has
			
 
				     a malformed one, or when the process JSON isn't parseable — the slice
			
@@ -3672,7 +3827,11 @@ def _patch_process_support_settings(process_json: str, source_3mf_bytes: bytes)
 
				     if not isinstance(process_cfg, dict):
			
 
				         return process_json
			
 
				 
			
 
				-    carried = {key: src_cfg[key] for key in _SOURCE_PROCESS_SUPPORT_KEYS_TO_PRESERVE if key in src_cfg}
			
 
				+    carried = {
			
 
				+        key: src_cfg[key] for key in _SOURCE_PROCESS_SUPPORT_KEYS_TO_PRESERVE if key in src_cfg and key not in declined
			
 
				+    }
			
 
				+    if not carried:
			
 
				+        return process_json
			
 
				     process_cfg.update(carried)
			
 
				     # Logged because this is the one layer of the process JSON the user
			
 
				     # can't see coming: the slice modal shows the picked preset's values,
			
@@ -3807,6 +3966,11 @@ async def _run_slicer_with_fallback(
 
				         assert ref is not None, "schema validator guarantees filament list is non-None"
			
 
				         filament_jsons.append(await resolve_preset_ref(db, user, ref, "filament"))
			
 
				 
			
 
				+    # Give every slot a colour before anything else touches the list, so the
			
 
				+    # unused-slot substitution below propagates a complete profile rather than
			
 
				+    # one that still has to be patched afterwards (#2977).
			
 
				+    filament_jsons = _patch_filament_colours(filament_jsons, request.filament_colours, model_bytes)
			
 
				+
			
 
				     # Bed-type override (#1337): patch curr_bed_type onto the resolved
			
 
				     # process JSON so the slicer's StaticPrintConfig pass picks up the
			
 
				     # user's pick instead of whatever the process preset defaults to.
			
@@ -3860,18 +4024,29 @@ async def _run_slicer_with_fallback(
 
				         # didn't touch) still drive the slice.
			
 
				         primary_bytes = _sanitize_project_settings_sentinels(primary_bytes)
			
 
				 
			
 
				+        # #2622: the process settings the file's designer moved off the stock
			
 
				+        # preset. Read once — the support patch below needs to know which of
			
 
				+        # them the user was shown, and the carry after it needs their values.
			
 
				+        design_offered = extract_design_process_overrides(primary_bytes)
			
 
				+
			
 
				+        declined_from_file = _declined_source_keys(design_offered, request.design_overrides)
			
 
				+
			
 
				         # #1881: preserve the source 3MF's support configuration on top of
			
 
				         # the picked process preset. Bambu's shipped process presets set
			
 
				         # `enable_support: 0` by default (supports are a per-print, not
			
 
				         # per-quality, decision); `--load-settings` is authoritative so
			
 
				         # without patching, the source's `enable_support: 1` + support-slot
			
 
				         # assignments get discarded and the slice comes out single-material
			
 
				-        # with a PVA slot loaded but never used.
			
 
				-        presets["process"] = _patch_process_support_settings(presets["process"], primary_bytes)
			
 
				+        # with a PVA slot loaded but never used. Bounded by the ticks: this
			
 
				+        # runs for a source that offers no per-key choice at all, and for the
			
 
				+        # keys of one that does but whose ticks the user left on.
			
 
				+        presets["process"] = _patch_process_support_settings(
			
 
				+            presets["process"], primary_bytes, declined=declined_from_file
			
 
				+        )
			
 
				 
			
 
				-        # #2622: carry the designer's own process tweaks onto the picked preset.
			
 
				-        # BambuStudio records exactly which keys deviate from the system preset
			
 
				-        # in `different_settings_to_system`, so a MakerWorld author's 5 walls /
			
 
				+        # Carry the designer's tweaks onto the picked preset. BambuStudio
			
 
				+        # records exactly which keys deviate from the system preset in
			
 
				+        # `different_settings_to_system`, so a MakerWorld author's 5 walls /
			
 
				         # 100% infill / 0.1mm first layer survive a re-slice for another printer
			
 
				         # instead of being flattened by --load-settings. Opt-in per key: only the
			
 
				         # keys the caller names are applied, and only if the source really lists
			
@@ -3880,7 +4055,7 @@ async def _run_slicer_with_fallback(
 
				         if request.design_overrides:
			
 
				             presets["process"] = apply_design_overrides(
			
 
				                 presets["process"],
			
 
				-                extract_design_process_overrides(primary_bytes),
			
 
				+                design_offered,
			
 
				                 request.design_overrides,
			
 
				             )
			
 
				 
			
@@ -4231,6 +4406,21 @@ async def _run_slicer_with_fallback(
 
				         )
			
 
				         raise HTTPException(status_code=502, detail=missing_start_gcode_message(request.printer_preset.id))
			
 
				 
			
 
				+    # Found while investigating #2977: a filament preset the sidecar's bundle
			
 
				+    # cannot resolve is not an error there — the CLI inherits nothing and
			
 
				+    # slices with its own defaults, so a PETG pick comes back as PLA at 200 C.
			
 
				+    # Warned rather than refused: the file prints, and the user may well have
			
 
				+    # meant to slice with a profile their sidecar image predates. Skipped on
			
 
				+    # the embedded-settings path, which sends no filament profiles for the
			
 
				+    # bundle to resolve in the first place.
			
 
				+    if not used_embedded_settings:
			
 
				+        unresolved = unresolved_filament_slots(result.content, export_3mf=bool(request.export_3mf))
			
 
				+        if unresolved:
			
 
				+            logger.warning(
			
 
				+                "%s",
			
 
				+                unresolved_filament_message(unresolved, [ref.id for ref in request.filament_presets]),
			
 
				+            )
			
 
				+
			
 
				     return result, used_embedded_settings
			
 
				 
			
 
				 
			
--- a/backend/app/api/routes/location_ha_sensors.py
+++ b/backend/app/api/routes/location_ha_sensors.py
@@ -0,0 +1,324 @@
 
				+"""API routes for Home Assistant sensors bound to a storage location (#2824)."""
			
 
				+
			
 
				+import logging
			
 
				+
			
 
				+from fastapi import APIRouter, Depends, HTTPException
			
 
				+from sqlalchemy import select
			
 
				+from sqlalchemy.exc import IntegrityError
			
 
				+from sqlalchemy.ext.asyncio import AsyncSession
			
 
				+
			
 
				+from backend.app.core.auth import RequirePermissionIfAuthEnabled
			
 
				+from backend.app.core.database import get_db
			
 
				+from backend.app.core.permissions import Permission
			
 
				+from backend.app.models.location import Location
			
 
				+from backend.app.models.location_ha_sensor import LocationHASensor
			
 
				+from backend.app.models.user import User
			
 
				+from backend.app.schemas.location_ha_sensor import (
			
 
				+    HADisplayEntity,
			
 
				+    LocationHASensorCreate,
			
 
				+    LocationHASensorReading,
			
 
				+    LocationHASensorResponse,
			
 
				+    LocationHASensorUpdate,
			
 
				+)
			
 
				+from backend.app.services.homeassistant import homeassistant_service
			
 
				+from backend.app.services.location_ha_sensor_manager import location_ha_sensor_manager
			
 
				+
			
 
				+logger = logging.getLogger(__name__)
			
 
				+
			
 
				+router = APIRouter(prefix="/location-ha-sensors", tags=["location-ha-sensors"])
			
 
				+
			
 
				+# Reuse the smart-plug permissions, same as ha_sensors.py: both surfaces are
			
 
				+# "the Home Assistant integration", just scoped to a location instead of a
			
 
				+# printer. INVENTORY_* would put HA entity bindings behind
			
 
				+# can_manage_inventory, which defaults to on for API keys (see auth.py) —
			
 
				+# an inventory-scoped key (e.g. a SpoolBuddy kiosk) would then be able to
			
 
				+# create, edit and delete HA sensor bindings, a capability the printer
			
 
				+# sibling deliberately keeps admin-only by leaving SMART_PLUGS_CREATE/
			
 
				+# UPDATE/DELETE off the API-key allowlist entirely.
			
 
				+_READ = RequirePermissionIfAuthEnabled(Permission.SMART_PLUGS_READ)
			
 
				+_CREATE = RequirePermissionIfAuthEnabled(Permission.SMART_PLUGS_CREATE)
			
 
				+_UPDATE = RequirePermissionIfAuthEnabled(Permission.SMART_PLUGS_UPDATE)
			
 
				+_DELETE = RequirePermissionIfAuthEnabled(Permission.SMART_PLUGS_DELETE)
			
 
				+
			
 
				+
			
 
				+# Mirrors categoryFor() in LocationHASensorModal.tsx, which also gates that
			
 
				+# dialog's entity picker. A device class outside these three has no category
			
 
				+# and is not subject to the one-per-location rule below.
			
 
				+#
			
 
				+# "moisture" is deliberately not mapped to humidity: it is Home Assistant's
			
 
				+# binary wet/dry class, so a leak detector would otherwise block a real
			
 
				+# hygrometer on the same location, and it could not carry the category's
			
 
				+# thresholds anyway — the schema rejects alert_above/alert_below for
			
 
				+# kind="binary".
			
 
				+_CATEGORY_BY_DEVICE_CLASS = {
			
 
				+    "temperature": "temperature",
			
 
				+    "humidity": "humidity",
			
 
				+    "battery": "battery",
			
 
				+}
			
 
				+
			
 
				+
			
 
				+def _category_for(device_class: str | None) -> str | None:
			
 
				+    return _CATEGORY_BY_DEVICE_CLASS.get(device_class) if device_class else None
			
 
				+
			
 
				+
			
 
				+async def _reject_duplicate_category(
			
 
				+    db: AsyncSession,
			
 
				+    location_id: int,
			
 
				+    device_class: str | None,
			
 
				+    exclude_sensor_id: int | None = None,
			
 
				+) -> None:
			
 
				+    """One sensor per category per location, enforced here and not only in the UI.
			
 
				+
			
 
				+    The inventory column and the card footer both pick their reading with a
			
 
				+    single ``find`` over the location's sensors, so a second temperature
			
 
				+    sensor does not show up alongside the first — it silently shadows it
			
 
				+    depending on row order. The modal already prompts to replace rather than
			
 
				+    add, so this closes the same rule for direct API callers instead of
			
 
				+    leaving the guarantee resting on the client.
			
 
				+    """
			
 
				+    category = _category_for(device_class)
			
 
				+    if category is None:
			
 
				+        return
			
 
				+
			
 
				+    query = select(LocationHASensor).where(LocationHASensor.location_id == location_id)
			
 
				+    if exclude_sensor_id is not None:
			
 
				+        query = query.where(LocationHASensor.id != exclude_sensor_id)
			
 
				+
			
 
				+    result = await db.execute(query)
			
 
				+    for other in result.scalars().all():
			
 
				+        if _category_for(other.device_class) == category:
			
 
				+            raise HTTPException(
			
 
				+                400,
			
 
				+                f"This location already has a {category} sensor ({other.entity_id}). "
			
 
				+                "Edit that sensor to point at a different entity instead.",
			
 
				+            )
			
 
				+
			
 
				+
			
 
				+async def _refresh_quietly(sensor: LocationHASensor, db: AsyncSession) -> None:
			
 
				+    """Take a first reading without letting it fail the write that preceded it.
			
 
				+
			
 
				+    The sensor row is committed before this runs. A failure here costs the
			
 
				+    card one poll interval of blank state, which is not worth turning a
			
 
				+    successful save into an error response.
			
 
				+    """
			
 
				+    try:
			
 
				+        await location_ha_sensor_manager.refresh_one(db, sensor)
			
 
				+    except Exception as e:
			
 
				+        logger.warning("Could not read %s right after saving it: %s", sensor.entity_id, e)
			
 
				+
			
 
				+
			
 
				+@router.get("/", response_model=list[LocationHASensorResponse])
			
 
				+async def list_location_ha_sensors(
			
 
				+    location_id: int | None = None,
			
 
				+    db: AsyncSession = Depends(get_db),
			
 
				+    _: User | None = _READ,
			
 
				+):
			
 
				+    """List configured sensors, grouped by location and in display order."""
			
 
				+    query = select(LocationHASensor)
			
 
				+    if location_id is not None:
			
 
				+        query = query.where(LocationHASensor.location_id == location_id)
			
 
				+    result = await db.execute(query.order_by(LocationHASensor.location_id, LocationHASensor.sort_order))
			
 
				+    return list(result.scalars().all())
			
 
				+
			
 
				+
			
 
				+# Must precede /{sensor_id} so "entities" is not parsed as an id.
			
 
				+@router.get("/entities", response_model=list[HADisplayEntity])
			
 
				+async def list_bindable_entities(
			
 
				+    search: str | None = None,
			
 
				+    db: AsyncSession = Depends(get_db),
			
 
				+    _: User | None = _READ,
			
 
				+):
			
 
				+    """List the Home Assistant entities that can be bound to a storage location."""
			
 
				+    from backend.app.api.routes.settings import get_homeassistant_settings
			
 
				+
			
 
				+    ha_settings = await get_homeassistant_settings(db)
			
 
				+    if not ha_settings["ha_url"] or not ha_settings["ha_token"]:
			
 
				+        raise HTTPException(
			
 
				+            400,
			
 
				+            "Home Assistant not configured. Please set HA URL and token in Settings → Network → Home Assistant.",
			
 
				+        )
			
 
				+
			
 
				+    entities = await homeassistant_service.list_display_entities(ha_settings["ha_url"], ha_settings["ha_token"], search)
			
 
				+    return [HADisplayEntity(**e) for e in entities]
			
 
				+
			
 
				+
			
 
				+@router.get("/by-location/{location_id}/readings", response_model=list[LocationHASensorReading])
			
 
				+async def get_location_sensor_readings(
			
 
				+    location_id: int,
			
 
				+    show_on_card: bool = True,
			
 
				+    db: AsyncSession = Depends(get_db),
			
 
				+    _: User | None = _READ,
			
 
				+):
			
 
				+    """Live state of a location's card-visible sensors.
			
 
				+
			
 
				+    Served from the poller's cache, so a page full of filament cards costs
			
 
				+    Home Assistant nothing. A sensor the poller has not reached yet falls
			
 
				+    back to its last persisted state, marked unreachable, rather than
			
 
				+    vanishing from the card on every restart.
			
 
				+    """
			
 
				+    conditions = [LocationHASensor.location_id == location_id]
			
 
				+    if show_on_card:
			
 
				+        conditions.append(LocationHASensor.show_on_card.is_(True))
			
 
				+
			
 
				+    result = await db.execute(
			
 
				+        select(LocationHASensor).where(*conditions).order_by(LocationHASensor.sort_order, LocationHASensor.id)
			
 
				+    )
			
 
				+
			
 
				+    readings = []
			
 
				+    for sensor in result.scalars().all():
			
 
				+        cached = location_ha_sensor_manager.get_reading(sensor.id)
			
 
				+        readings.append(
			
 
				+            LocationHASensorReading(
			
 
				+                id=sensor.id,
			
 
				+                name=sensor.name,
			
 
				+                entity_id=sensor.entity_id,
			
 
				+                kind=sensor.kind,
			
 
				+                device_class=sensor.device_class,
			
 
				+                unit=sensor.unit,
			
 
				+                state=cached.state if cached else sensor.last_state,
			
 
				+                value=cached.value if cached else None,
			
 
				+                alerting=cached.alerting if cached else False,
			
 
				+                reachable=cached.reachable if cached else False,
			
 
				+                alert_state=sensor.alert_state,
			
 
				+                alert_above=sensor.alert_above,
			
 
				+                alert_below=sensor.alert_below,
			
 
				+                last_changed=sensor.last_changed,
			
 
				+                show_on_card=sensor.show_on_card,
			
 
				+            )
			
 
				+        )
			
 
				+    return readings
			
 
				+
			
 
				+
			
 
				+@router.post("/", response_model=LocationHASensorResponse)
			
 
				+async def create_location_ha_sensor(
			
 
				+    data: LocationHASensorCreate,
			
 
				+    db: AsyncSession = Depends(get_db),
			
 
				+    _: User | None = _CREATE,
			
 
				+):
			
 
				+    """Bind a Home Assistant entity to a storage location."""
			
 
				+    location = await db.get(Location, data.location_id)
			
 
				+    if not location:
			
 
				+        raise HTTPException(404, "Location not found")
			
 
				+
			
 
				+    existing = await db.execute(
			
 
				+        select(LocationHASensor).where(
			
 
				+            LocationHASensor.location_id == data.location_id,
			
 
				+            LocationHASensor.entity_id == data.entity_id,
			
 
				+        )
			
 
				+    )
			
 
				+    if existing.scalar_one_or_none():
			
 
				+        raise HTTPException(400, f"{data.entity_id} is already bound to this location")
			
 
				+
			
 
				+    await _reject_duplicate_category(db, data.location_id, data.device_class)
			
 
				+
			
 
				+    sensor = LocationHASensor(**data.model_dump())
			
 
				+    db.add(sensor)
			
 
				+    try:
			
 
				+        await db.commit()
			
 
				+    except IntegrityError:
			
 
				+        # The duplicate check above is read-then-insert, so a concurrent
			
 
				+        # create for the same (location, entity) can get past it — the unique
			
 
				+        # index is the backstop, and its loser should read like the pre-check.
			
 
				+        await db.rollback()
			
 
				+        raise HTTPException(400, f"{data.entity_id} is already bound to this location") from None
			
 
				+    await db.refresh(sensor)
			
 
				+    logger.info("Bound HA entity %s to location %s as '%s'", sensor.entity_id, sensor.location_id, sensor.name)
			
 
				+
			
 
				+    # Read it once now so the card shows a state immediately instead of after
			
 
				+    # the next poll tick. Best-effort: the row is already committed, so
			
 
				+    # letting a Home Assistant hiccup 500 the request would report a failure
			
 
				+    # for work that succeeded — and the retry would come back "already bound".
			
 
				+    await _refresh_quietly(sensor, db)
			
 
				+    return sensor
			
 
				+
			
 
				+
			
 
				+@router.get("/{sensor_id}", response_model=LocationHASensorResponse)
			
 
				+async def get_location_ha_sensor(
			
 
				+    sensor_id: int,
			
 
				+    db: AsyncSession = Depends(get_db),
			
 
				+    _: User | None = _READ,
			
 
				+):
			
 
				+    sensor = await db.get(LocationHASensor, sensor_id)
			
 
				+    if not sensor:
			
 
				+        raise HTTPException(404, "Sensor not found")
			
 
				+    return sensor
			
 
				+
			
 
				+
			
 
				+@router.patch("/{sensor_id}", response_model=LocationHASensorResponse)
			
 
				+async def update_location_ha_sensor(
			
 
				+    sensor_id: int,
			
 
				+    data: LocationHASensorUpdate,
			
 
				+    db: AsyncSession = Depends(get_db),
			
 
				+    _: User | None = _UPDATE,
			
 
				+):
			
 
				+    sensor = await db.get(LocationHASensor, sensor_id)
			
 
				+    if not sensor:
			
 
				+        raise HTTPException(404, "Sensor not found")
			
 
				+
			
 
				+    updates = data.model_dump(exclude_unset=True)
			
 
				+
			
 
				+    # Re-run the create-time rules against the merged row. A PATCH that only
			
 
				+    # sets show_on_card has no entity_id or alert_state in its payload, so the
			
 
				+    # schema alone cannot tell whether the result is coherent.
			
 
				+    merged = {field: getattr(sensor, field) for field in LocationHASensorCreate.model_fields}
			
 
				+    merged.update(updates)
			
 
				+    try:
			
 
				+        LocationHASensorCreate(**merged)
			
 
				+    except ValueError as e:
			
 
				+        raise HTTPException(422, str(e)) from e
			
 
				+
			
 
				+    # Same uniqueness rule as create: repointing a sensor at an entity the
			
 
				+    # location already has would leave two rows fighting over one reading.
			
 
				+    new_entity = updates.get("entity_id")
			
 
				+    if new_entity and new_entity != sensor.entity_id:
			
 
				+        clash = await db.execute(
			
 
				+            select(LocationHASensor).where(
			
 
				+                LocationHASensor.location_id == sensor.location_id,
			
 
				+                LocationHASensor.entity_id == new_entity,
			
 
				+                LocationHASensor.id != sensor.id,
			
 
				+            )
			
 
				+        )
			
 
				+        if clash.scalar_one_or_none():
			
 
				+            raise HTTPException(400, f"{new_entity} is already bound to this location")
			
 
				+
			
 
				+    # Same one-per-category rule as create, against the merged row and
			
 
				+    # excluding this sensor — repointing a sensor within its own category
			
 
				+    # (the modal's replace flow) stays allowed.
			
 
				+    if "device_class" in updates:
			
 
				+        await _reject_duplicate_category(db, sensor.location_id, merged["device_class"], exclude_sensor_id=sensor.id)
			
 
				+
			
 
				+    for field, value in updates.items():
			
 
				+        setattr(sensor, field, value)
			
 
				+    # Read before commit: after a rollback the instance is expired, and
			
 
				+    # touching its attributes from async code raises MissingGreenlet.
			
 
				+    entity_id = sensor.entity_id
			
 
				+    try:
			
 
				+        await db.commit()
			
 
				+    except IntegrityError:
			
 
				+        # Same backstop as create: the clash check above races a concurrent
			
 
				+        # write, and the unique index decides who loses.
			
 
				+        await db.rollback()
			
 
				+        raise HTTPException(400, f"{entity_id} is already bound to this location") from None
			
 
				+    await db.refresh(sensor)
			
 
				+
			
 
				+    # The entity or its alert rule may have changed under the cached reading.
			
 
				+    await _refresh_quietly(sensor, db)
			
 
				+    return sensor
			
 
				+
			
 
				+
			
 
				+@router.delete("/{sensor_id}")
			
 
				+async def delete_location_ha_sensor(
			
 
				+    sensor_id: int,
			
 
				+    db: AsyncSession = Depends(get_db),
			
 
				+    _: User | None = _DELETE,
			
 
				+):
			
 
				+    sensor = await db.get(LocationHASensor, sensor_id)
			
 
				+    if not sensor:
			
 
				+        raise HTTPException(404, "Sensor not found")
			
 
				+
			
 
				+    name = sensor.name
			
 
				+    await db.delete(sensor)
			
 
				+    await db.commit()
			
 
				+    location_ha_sensor_manager.forget(sensor_id)
			
 
				+    logger.info("Removed location HA sensor '%s'", name)
			
 
				+    return {"message": f"Sensor '{name}' removed"}
			
--- a/backend/app/api/routes/notifications.py
+++ b/backend/app/api/routes/notifications.py
@@ -51,6 +51,11 @@ def _provider_to_dict(provider: NotificationProvider) -> dict:
 
				         "on_ai_failure_detection": provider.on_ai_failure_detection,
			
 
				         "on_filament_low": provider.on_filament_low,
			
 
				         "on_maintenance_due": provider.on_maintenance_due,
			
 
				+        # Home Assistant sensor alerts (#1148, #2824). Both directions of this
			
 
				+        # file are hand-maintained field maps, so a column missing here reads
			
 
				+        # back as the schema default (False) no matter what the row holds.
			
 
				+        "on_ha_sensor_alert": provider.on_ha_sensor_alert,
			
 
				+        "on_location_ha_sensor_alert": provider.on_location_ha_sensor_alert,
			
 
				         # AMS environmental alarms (regular AMS)
			
 
				         "on_ams_humidity_high": provider.on_ams_humidity_high,
			
 
				         "on_ams_temperature_high": provider.on_ams_temperature_high,
			
@@ -65,6 +70,11 @@ def _provider_to_dict(provider: NotificationProvider) -> dict:
 
				         "on_bed_cooled": provider.on_bed_cooled,
			
 
				         # First layer complete
			
 
				         "on_first_layer_complete": provider.on_first_layer_complete,
			
 
				+        # Inventory stock alerts. Absent here, the toggles above always read
			
 
				+        # back off no matter what the row holds — the same hand-maintained
			
 
				+        # field map the Home Assistant comment warns about.
			
 
				+        "on_stock_reorder_alert": provider.on_stock_reorder_alert,
			
 
				+        "on_stock_break_alert": provider.on_stock_break_alert,
			
 
				         # Print queue events
			
 
				         "on_queue_job_added": provider.on_queue_job_added,
			
 
				         "on_queue_job_assigned": provider.on_queue_job_assigned,
			
@@ -135,6 +145,9 @@ async def create_notification_provider(
 
				         on_ai_failure_detection=provider_data.on_ai_failure_detection,
			
 
				         on_filament_low=provider_data.on_filament_low,
			
 
				         on_maintenance_due=provider_data.on_maintenance_due,
			
 
				+        # Home Assistant sensor alerts (#1148, #2824)
			
 
				+        on_ha_sensor_alert=provider_data.on_ha_sensor_alert,
			
 
				+        on_location_ha_sensor_alert=provider_data.on_location_ha_sensor_alert,
			
 
				         # AMS environmental alarms (regular AMS)
			
 
				         on_ams_humidity_high=provider_data.on_ams_humidity_high,
			
 
				         on_ams_temperature_high=provider_data.on_ams_temperature_high,
			
@@ -149,6 +162,9 @@ async def create_notification_provider(
 
				         on_bed_cooled=provider_data.on_bed_cooled,
			
 
				         # First layer complete
			
 
				         on_first_layer_complete=provider_data.on_first_layer_complete,
			
 
				+        # Inventory stock alerts
			
 
				+        on_stock_reorder_alert=provider_data.on_stock_reorder_alert,
			
 
				+        on_stock_break_alert=provider_data.on_stock_break_alert,
			
 
				         # Print queue events
			
 
				         on_queue_job_added=provider_data.on_queue_job_added,
			
 
				         on_queue_job_assigned=provider_data.on_queue_job_assigned,
			
--- a/backend/app/api/routes/obico.py
+++ b/backend/app/api/routes/obico.py
@@ -53,11 +53,17 @@ async def get_printer_status(
 
				     # Error strings can embed configured URLs (ML API base, external URL), so
			
 
				     # they stay behind settings:read like the rest of the configuration.
			
 
				     can_see_error = user is None or user.has_permission(Permission.SETTINGS_READ.value)
			
 
				+    per_printer = obico_detection_service.get_per_printer()
			
 
				+    if not can_see_error:
			
 
				+        # The "error" *class* is not configuration — a printers:read user still
			
 
				+        # needs to know their print is not being watched. Only the reason, which
			
 
				+        # can name a URL, is withheld.
			
 
				+        per_printer = {pid: {**entry, "error": None} for pid, entry in per_printer.items()}
			
 
				     return {
			
 
				         "enabled": settings["enabled"],
			
 
				         # None = all printers are monitored
			
 
				         "monitored_printers": sorted(enabled_printers) if enabled_printers is not None else None,
			
 
				-        "per_printer": obico_detection_service.get_per_printer(),
			
 
				+        "per_printer": per_printer,
			
 
				         "last_error": obico_detection_service._last_error if can_see_error else None,
			
 
				     }
			
 
				 
			
--- a/backend/app/api/routes/print_log.py
+++ b/backend/app/api/routes/print_log.py
@@ -237,6 +237,12 @@ _FAILURE_REASON_KEYS = frozenset(
 
				         "underExtrusion",
			
 
				         "powerFailure",
			
 
				         "userCancelled",
			
 
				+        # Written by the two stale-archive paths in main.py when no end-of-print
			
 
				+        # status ever arrived (issue #2974). It has to be in the vocabulary, not
			
 
				+        # just tolerated: the archive editor clears any stored value it does not
			
 
				+        # recognise, so leaving it out would delete the classification on the
			
 
				+        # next save of such an archive.
			
 
				+        "noStatusUpdate",
			
 
				         "other",
			
 
				     }
			
 
				 )
			
--- a/backend/app/api/routes/print_queue.py
+++ b/backend/app/api/routes/print_queue.py
@@ -50,6 +50,7 @@ from backend.app.services.print_batch import (
 
				     dispatch_remaining,
			
 
				     load_progress,
			
 
				     refresh_batch_status,
			
 
				+    refresh_batch_status_for_item,
			
 
				 )
			
 
				 from backend.app.services.print_cost_estimate import estimate_queue_source_cost
			
 
				 from backend.app.utils.printer_models import (
			
@@ -201,6 +202,65 @@ def _assert_can_queue_library_file(library_file: LibraryFile, current_user: User
 
				         raise HTTPException(404, "Library file not found")
			
 
				 
			
 
				 
			
 
				+async def _is_orders_last_source(db: AsyncSession, item: PrintQueueItem) -> bool:
			
 
				+    """True when deleting *item* would leave an order owing runs it can't queue.
			
 
				+
			
 
				+    Dispatch produces the runs an order still owes by cloning an existing
			
 
				+    queue item for the same plate — that row is the only record of the printer
			
 
				+    target, AMS mapping and print options the user chose. Delete the last one
			
 
				+    while the plate still has a target and the order is stranded: it goes on
			
 
				+    reporting work outstanding with no way left to produce it (#2960).
			
 
				+    """
			
 
				+    if item.batch_id is None:
			
 
				+        return False
			
 
				+
			
 
				+    # A cancelled order can never dispatch again, so nothing about it can be
			
 
				+    # stranded and its leftover rows must stay deletable — tidying up after a
			
 
				+    # cancel is the most likely reason anyone deletes them.
			
 
				+    status = (await db.execute(select(PrintBatch.status).where(PrintBatch.id == item.batch_id))).scalar_one_or_none()
			
 
				+    if status == "cancelled":
			
 
				+        return False
			
 
				+
			
 
				+    plate_scope = (
			
 
				+        PrintBatchPlate.plate_id == item.plate_id if item.plate_id is not None else PrintBatchPlate.plate_id.is_(None)
			
 
				+    )
			
 
				+    # first(), not scalar_one_or_none(): a UNIQUE(batch_id, plate_id) does not
			
 
				+    # constrain NULL plate_ids on either dialect, and a duplicate whole-file
			
 
				+    # row must not turn a delete into a 500.
			
 
				+    target = (
			
 
				+        (
			
 
				+            await db.execute(
			
 
				+                select(PrintBatchPlate.quantity_target)
			
 
				+                .where(PrintBatchPlate.batch_id == item.batch_id)
			
 
				+                .where(plate_scope)
			
 
				+                .order_by(PrintBatchPlate.quantity_target.desc())
			
 
				+                .limit(1)
			
 
				+            )
			
 
				+        )
			
 
				+        .scalars()
			
 
				+        .first()
			
 
				+    )
			
 
				+    # No target row: a grouping, or a plate assigned into the order by hand.
			
 
				+    # A target of 0 is legal and means the plate is not wanted. Neither owes
			
 
				+    # anything, so neither can be stranded.
			
 
				+    if not target:
			
 
				+        return False
			
 
				+
			
 
				+    item_scope = (
			
 
				+        PrintQueueItem.plate_id == item.plate_id if item.plate_id is not None else PrintQueueItem.plate_id.is_(None)
			
 
				+    )
			
 
				+    survivor = (
			
 
				+        await db.execute(
			
 
				+            select(PrintQueueItem.id)
			
 
				+            .where(PrintQueueItem.batch_id == item.batch_id)
			
 
				+            .where(item_scope)
			
 
				+            .where(PrintQueueItem.id != item.id)
			
 
				+            .limit(1)
			
 
				+        )
			
 
				+    ).scalar_one_or_none()
			
 
				+    return survivor is None
			
 
				+
			
 
				+
			
 
				 async def _assert_can_dispatch_batch_sources(db: AsyncSession, batch_id: int, current_user: User | None) -> None:
			
 
				     """Apply the ``POST /queue/`` source-file gates to everything a dispatch would print.
			
 
				 
			
@@ -1743,6 +1803,7 @@ async def _build_batch_response(
 
				         has_targets=progress.has_targets,
			
 
				         target_count=progress.target,
			
 
				         remaining_count=progress.remaining,
			
 
				+        dispatchable_count=progress.dispatchable_remaining,
			
 
				         actual_cost=progress.actual_cost,
			
 
				         estimated_remaining_cost=progress.estimated_remaining_cost,
			
 
				         filament_used_grams=progress.filament_used_grams,
			
@@ -1764,6 +1825,7 @@ async def _build_batch_response(
 
				                 estimated_remaining_cost=plate.estimated_remaining_cost,
			
 
				                 filament_used_grams=plate.filament_used_grams,
			
 
				                 print_time_seconds=plate.print_time_seconds,
			
 
				+                can_dispatch=plate.can_dispatch,
			
 
				             )
			
 
				             for plate in progress.plates
			
 
				         ],
			
@@ -1992,7 +2054,15 @@ async def delete_queue_item(
 
				         )
			
 
				     ),
			
 
				 ):
			
 
				-    """Remove an item from the queue."""
			
 
				+    """Remove an item from the queue.
			
 
				+
			
 
				+    An order's last surviving run for a plate is cancelled instead of deleted
			
 
				+    (#2960). The row is what a later dispatch clones, so removing it would
			
 
				+    leave the order reporting work outstanding that nothing could ever
			
 
				+    produce. A completed run is exempt: it is the record of something that was
			
 
				+    actually made, and rewriting it as cancelled would falsify the order's
			
 
				+    progress.
			
 
				+    """
			
 
				     user, can_modify_all = auth_result
			
 
				 
			
 
				     result = await db.execute(select(PrintQueueItem).where(PrintQueueItem.id == item_id))
			
@@ -2008,13 +2078,22 @@ async def delete_queue_item(
 
				     if item.status == "printing":
			
 
				         raise HTTPException(400, "Cannot delete item that is currently printing")
			
 
				 
			
 
				+    keep_as_cancelled = item.status != "completed" and await _is_orders_last_source(db, item)
			
 
				+
			
 
				     await release_budget_reservation(
			
 
				         db,
			
 
				         source_type="print_queue",
			
 
				         source_id=item.id,
			
 
				         status="released",
			
 
				     )
			
 
				-    await db.delete(item)
			
 
				+    if keep_as_cancelled:
			
 
				+        item.status = "cancelled"
			
 
				+        await db.flush()
			
 
				+        # The order may have been sitting on "completed" if this run's target
			
 
				+        # was met by it; cancelling reopens it.
			
 
				+        await refresh_batch_status_for_item(db, item.id)
			
 
				+    else:
			
 
				+        await db.delete(item)
			
 
				     await db.commit()
			
 
				 
			
 
				     # Stop an in-flight preheat for this item: the dispatch coroutine is
			
@@ -2023,8 +2102,15 @@ async def delete_queue_item(
 
				 
			
 
				     _scheduler.notify_dispatch_cancelled(item_id)
			
 
				 
			
 
				+    if keep_as_cancelled:
			
 
				+        logger.info("Kept queue item %s as cancelled — last source for its batch order plate", item_id)
			
 
				+        return {
			
 
				+            "message": "Item cancelled rather than deleted: it is the only run the order can re-queue this plate from",
			
 
				+            "deleted": False,
			
 
				+        }
			
 
				+
			
 
				     logger.info("Deleted queue item %s", item_id)
			
 
				-    return {"message": "Queue item deleted"}
			
 
				+    return {"message": "Queue item deleted", "deleted": True}
			
 
				 
			
 
				 
			
 
				 @router.post("/reorder")
			
--- a/backend/app/api/routes/printers.py
+++ b/backend/app/api/routes/printers.py
--- a/backend/app/api/routes/scheduled_dryings.py
+++ b/backend/app/api/routes/scheduled_dryings.py
@@ -0,0 +1,107 @@
 
				+"""Scheduled (delayed) manual AMS drying runs (#2638)."""
			
 
				+
			
 
				+from fastapi import APIRouter, Depends, HTTPException
			
 
				+from sqlalchemy import select
			
 
				+from sqlalchemy.ext.asyncio import AsyncSession
			
 
				+
			
 
				+from backend.app.core.auth import RequirePermissionIfAuthEnabled
			
 
				+from backend.app.core.database import get_db
			
 
				+from backend.app.core.permissions import Permission
			
 
				+from backend.app.models.printer import Printer
			
 
				+from backend.app.models.scheduled_drying import ScheduledDrying
			
 
				+from backend.app.models.user import User
			
 
				+from backend.app.schemas.scheduled_drying import ScheduledDryingCreate, ScheduledDryingResponse
			
 
				+from backend.app.services import drying_preflight
			
 
				+from backend.app.services.printer_manager import printer_manager
			
 
				+from backend.app.utils.local_time import utcnow_naive
			
 
				+
			
 
				+router = APIRouter(prefix="/scheduled-dryings", tags=["scheduled-dryings"])
			
 
				+
			
 
				+ACTIVE_STATUSES = ("pending", "running")
			
 
				+# Failed rows are listed too. A run can only fail at dispatch (the firmware
			
 
				+# turns out too old, say), which is exactly the case a schedule-time check on
			
 
				+# an offline printer cannot catch, so without this the run just disappears and
			
 
				+# only the backend log knows why. The client dismisses the row to clear it.
			
 
				+LISTED_STATUSES = (*ACTIVE_STATUSES, "failed")
			
 
				+
			
 
				+
			
 
				+@router.post("", response_model=ScheduledDryingResponse)
			
 
				+async def create_scheduled_drying(
			
 
				+    payload: ScheduledDryingCreate,
			
 
				+    user: User | None = RequirePermissionIfAuthEnabled(Permission.PRINTERS_CONTROL),
			
 
				+    db: AsyncSession = Depends(get_db),
			
 
				+):
			
 
				+    result = await db.execute(select(Printer).where(Printer.id == payload.printer_id))
			
 
				+    printer = result.scalar_one_or_none()
			
 
				+    if not printer:
			
 
				+        raise HTTPException(404, "Printer not found")
			
 
				+
			
 
				+    # Fail fast in the UI rather than hours later with nobody watching. An
			
 
				+    # offline printer is still schedulable: only its model is judged here.
			
 
				+    state = printer_manager.get_status(payload.printer_id)
			
 
				+    unsupported = drying_preflight.check_drying_supported(
			
 
				+        printer.model,
			
 
				+        state.firmware_version if state else None,
			
 
				+        require_firmware=state is not None,
			
 
				+    )
			
 
				+    if unsupported:
			
 
				+        raise HTTPException(400, unsupported)
			
 
				+
			
 
				+    if payload.start_after is not None and payload.start_after <= utcnow_naive():
			
 
				+        raise HTTPException(400, "start_after must be in the future")
			
 
				+
			
 
				+    row = ScheduledDrying(
			
 
				+        printer_id=payload.printer_id,
			
 
				+        ams_id=payload.ams_id,
			
 
				+        temp=payload.temp,
			
 
				+        duration_hours=payload.duration_hours,
			
 
				+        filament=payload.filament,
			
 
				+        rotate_tray=payload.rotate_tray,
			
 
				+        start_after=payload.start_after,
			
 
				+        created_by_id=user.id if user else None,
			
 
				+    )
			
 
				+    db.add(row)
			
 
				+    await db.commit()
			
 
				+    await db.refresh(row)
			
 
				+    return row
			
 
				+
			
 
				+
			
 
				+@router.get("", response_model=list[ScheduledDryingResponse])
			
 
				+async def list_scheduled_dryings(
			
 
				+    printer_id: int | None = None,
			
 
				+    _: User | None = RequirePermissionIfAuthEnabled(Permission.PRINTERS_READ),
			
 
				+    db: AsyncSession = Depends(get_db),
			
 
				+):
			
 
				+    query = select(ScheduledDrying).where(ScheduledDrying.status.in_(LISTED_STATUSES))
			
 
				+    if printer_id is not None:
			
 
				+        query = query.where(ScheduledDrying.printer_id == printer_id)
			
 
				+    result = await db.execute(query.order_by(ScheduledDrying.start_after.asc().nullsfirst(), ScheduledDrying.id.asc()))
			
 
				+    return list(result.scalars().all())
			
 
				+
			
 
				+
			
 
				+@router.delete("/{scheduled_drying_id}")
			
 
				+async def cancel_scheduled_drying(
			
 
				+    scheduled_drying_id: int,
			
 
				+    _: User | None = RequirePermissionIfAuthEnabled(Permission.PRINTERS_CONTROL),
			
 
				+    db: AsyncSession = Depends(get_db),
			
 
				+):
			
 
				+    result = await db.execute(select(ScheduledDrying).where(ScheduledDrying.id == scheduled_drying_id))
			
 
				+    row = result.scalar_one_or_none()
			
 
				+    if not row:
			
 
				+        raise HTTPException(404, "Scheduled drying not found")
			
 
				+    if row.status == "failed":
			
 
				+        # Terminal and now acknowledged; drop it so it stops being listed.
			
 
				+        await db.delete(row)
			
 
				+        await db.commit()
			
 
				+        return {"status": "dismissed", "id": scheduled_drying_id}
			
 
				+    if row.status not in ACTIVE_STATUSES:
			
 
				+        raise HTTPException(400, "Only pending, running or failed dryings can be cancelled")
			
 
				+
			
 
				+    if row.status == "running":
			
 
				+        # Best effort; cancellation proceeds even if the printer is offline.
			
 
				+        printer_manager.send_drying_command(row.printer_id, row.ams_id, 0, 0, mode=0)
			
 
				+
			
 
				+    row.status = "cancelled"
			
 
				+    row.completed_at = utcnow_naive()
			
 
				+    await db.commit()
			
 
				+    return {"status": "cancelled", "id": row.id}
			
--- a/backend/app/api/routes/settings.py
+++ b/backend/app/api/routes/settings.py
@@ -8,7 +8,7 @@ from pathlib import Path
 
				 from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
			
 
				 from fastapi.responses import FileResponse, JSONResponse
			
 
				 from pydantic import BaseModel, Field
			
 
				-from sqlalchemy import delete, func, select
			
 
				+from sqlalchemy import func, select
			
 
				 from sqlalchemy.ext.asyncio import AsyncSession
			
 
				 
			
 
				 from backend.app.core.auth import RequirePermissionIfAuthEnabled, caller_is_api_key, require_energy_cost_update
			
@@ -212,6 +212,16 @@ async def _build_settings_response(db: AsyncSession, is_api_key: bool = False) -
 
				             "low_stock_threshold",
			
 
				         ]:
			
 
				             settings_dict[setting.key] = float(setting.value)
			
 
				+        elif setting.key in [
			
 
				+            # Nullable floats. Settings storage stringifies None to the literal
			
 
				+            # "None", so these cannot go in the list above -- float("None")
			
 
				+            # raises and would take the whole settings response with it (#2905).
			
 
				+            "ams_temp_alarm",
			
 
				+        ]:
			
 
				+            try:
			
 
				+                settings_dict[setting.key] = float(setting.value)
			
 
				+            except (TypeError, ValueError):
			
 
				+                settings_dict[setting.key] = None
			
 
				         elif setting.key in [
			
 
				             "ams_humidity_good",
			
 
				             "ams_humidity_fair",
			
@@ -224,6 +234,7 @@ async def _build_settings_response(db: AsyncSession, is_api_key: bool = False) -
 
				             "stagger_group_size",
			
 
				             "stagger_interval_minutes",
			
 
				             "forecast_global_lead_time_days",
			
 
				+            "location_sensor_poll_interval",
			
 
				             "finance_budget_reset_day",
			
 
				             "session_max_hours",
			
 
				             "pipeline_max_copies",
			
@@ -446,6 +457,11 @@ _UI_PREFERENCE_FIELDS: tuple[str, ...] = (
 
				     "ams_humidity_fair",
			
 
				     "ams_temp_good",
			
 
				     "ams_temp_fair",
			
 
				+    # ams_temp_alarm is deliberately NOT here. This endpoint is unauthenticated
			
 
				+    # and exists so the UI can colour readings without SETTINGS_READ; the good /
			
 
				+    # fair bands are what the printer card colours by. The alarm threshold
			
 
				+    # changes no rendering anywhere -- only SettingsPage reads it, and that is
			
 
				+    # behind the settings permissions already (#2905).
			
 
				     "bed_cooled_threshold",
			
 
				     # Temperature / fan-speed presets for the printer-card popovers. Numbers
			
 
				     # only; no PII / credentials.
			
@@ -536,22 +552,24 @@ async def update_spoolman_settings(
 
				         now_enabled = new_val == "true"
			
 
				         await set_setting(db, "spoolman_enabled", new_val)
			
 
				 
			
 
				-        # Switching to Spoolman: clear built-in inventory slot assignments
			
 
				-        if not was_enabled and now_enabled:
			
 
				-            from backend.app.models.spool_assignment import SpoolAssignment
			
 
				-
			
 
				-            result = await db.execute(delete(SpoolAssignment))
			
 
				-            logger.info("Cleared %d spool assignments on switch to Spoolman mode", result.rowcount)
			
 
				-        # Switching back to internal mode: clear Spoolman slot assignments — the
			
 
				-        # symmetric counterpart of the clear above. Without this, stale
			
 
				-        # spoolman_slot_assignments rows linger and would wrongly count as
			
 
				-        # "assigned" in any mode-agnostic check (e.g. the missing-spool-
			
 
				-        # assignment notification, which unions both tables — #1473).
			
 
				-        elif was_enabled and not now_enabled:
			
 
				-            from backend.app.models.spoolman_slot_assignment import SpoolmanSlotAssignment
			
 
				-
			
 
				-            result = await db.execute(delete(SpoolmanSlotAssignment))
			
 
				-            logger.info("Cleared %d Spoolman slot assignments on switch to internal mode", result.rowcount)
			
 
				+        # Nothing is deleted on a mode change (#2812). Each mode keeps its slot
			
 
				+        # assignments in its own table, so both can hold rows at once and the
			
 
				+        # toggle is reversible: switching to Spoolman to see what it does, then
			
 
				+        # switching back, returns you to the assignments you had.
			
 
				+        #
			
 
				+        # This used to empty the other mode's table on every toggle. The reason
			
 
				+        # was real -- checks that read both tables would let a row in the mode
			
 
				+        # you are not using answer for the mode you are -- but the cost was that
			
 
				+        # inspecting a mode destroyed your configuration, with no confirmation
			
 
				+        # and no way back, and the deletion was unfiltered across every printer.
			
 
				+        # The readers that could be confused now ask which mode is active
			
 
				+        # (``spoolman_owns_assignments``), which is where that decision belongs:
			
 
				+        # the mode is a property of the install, not of the rows.
			
 
				+        if was_enabled != now_enabled:
			
 
				+            logger.info(
			
 
				+                "Inventory mode switched to %s; slot assignments in both tables kept",
			
 
				+                "Spoolman" if now_enabled else "built-in",
			
 
				+            )
			
 
				     if "spoolman_url" in settings:
			
 
				         await set_setting(db, "spoolman_url", normalize_str_setting("spoolman_url", settings["spoolman_url"]))
			
 
				     if "spoolman_sync_mode" in settings:
			
--- a/backend/app/api/routes/slicer_presets.py
+++ b/backend/app/api/routes/slicer_presets.py
@@ -309,7 +309,10 @@ async def _fetch_local_presets(db: AsyncSession) -> dict[str, list[UnifiedPreset
 
				 
			
 
				 
			
 
				 def _content_compatible_printers(content: dict) -> list[str] | None:
			
 
				-    """Pull ``compatible_printers`` out of an inline profile content dict.
			
 
				+    """Pull ``compatible_printers`` out of a profile content dict.
			
 
				+
			
 
				+    Serves both callers that have one: an Orca Cloud profile's inline
			
 
				+    ``content``, and an entry of the sidecar's bundled listing.
			
 
				 
			
 
				     Orca profiles carry it as a list of printer-preset names (the same shape
			
 
				     ``orca_profiles.py`` stores on import); a single-printer profile may store
			
@@ -403,13 +406,26 @@ async def _fetch_bundled_presets(db: AsyncSession, *, refresh: bool = False) ->
 
				                 continue
			
 
				             # Bundled presets are addressed by name (the slicer resolves them
			
 
				             # by name during the `inherits:` walk), so name doubles as id.
			
 
				-            extra: dict[str, str | None] = {}
			
 
				+            preset = UnifiedPreset(id=name, name=name, source="standard")
			
 
				             if slot == "filament":
			
 
				-                extra["filament_type"] = entry.get("filament_type")
			
 
				-                extra["filament_colour"] = entry.get("filament_colour")
			
 
				-            slots[slot].append(
			
 
				-                UnifiedPreset(id=name, name=name, source="standard", **extra),
			
 
				-            )
			
 
				+                preset.filament_type = entry.get("filament_type")
			
 
				+                preset.filament_colour = entry.get("filament_colour")
			
 
				+            if slot in ("process", "filament"):
			
 
				+                # The slicer's own compatible-printer list, and the only
			
 
				+                # truthful answer for several Bambu printers: the bundle ships
			
 
				+                # no process preset named after a P1S, an X1, an X1E or an H2D
			
 
				+                # Pro -- each one is served by another model's preset that
			
 
				+                # names it here. Inferring the printer from the preset NAME
			
 
				+                # instead read all 198 as belonging to the model in their
			
 
				+                # `@BBL` tag, so a P1S had zero compatible processes, the
			
 
				+                # dropdown hid every one of them, and the auto-pick landed on
			
 
				+                # an A1 0.2-nozzle process the CLI then refused (#2982).
			
 
				+                #
			
 
				+                # Older sidecars don't report the field. They return None here,
			
 
				+                # which leaves the SliceModal on the name matcher for the
			
 
				+                # standard tier -- degraded exactly as before, not broken.
			
 
				+                preset.compatible_printers = _content_compatible_printers(entry)
			
 
				+            slots[slot].append(preset)
			
 
				 
			
 
				     _bundled_cache = (now, slots)
			
 
				     return slots
			
--- a/backend/app/api/routes/spoolman.py
+++ b/backend/app/api/routes/spoolman.py
@@ -22,6 +22,9 @@ from backend.app.models.spoolman_k_profile import SpoolmanKProfile
 
				 from backend.app.models.spoolman_slot_assignment import SpoolmanSlotAssignment
			
 
				 from backend.app.models.user import User
			
 
				 from backend.app.services.printer_manager import printer_manager
			
 
				+from backend.app.services.slicer_filament_resolver import resolve_slicer_filament
			
 
				+from backend.app.services.slot_nozzle import resolve_slot_nozzle
			
 
				+from backend.app.services.spool_filament_preset import resolve_spoolman_preset
			
 
				 from backend.app.services.spoolman import (
			
 
				     SpoolmanClientError,
			
 
				     SpoolmanNotFoundError,
			
@@ -32,9 +35,10 @@ from backend.app.services.spoolman import (
 
				 )
			
 
				 from backend.app.utils.filament_ids import (
			
 
				     GENERIC_FILAMENT_IDS,
			
 
				-    MATERIAL_TEMPS,
			
 
				+    filament_id_to_setting_id,
			
 
				     normalize_slicer_filament,
			
 
				 )
			
 
				+from backend.app.utils.filament_types import nozzle_temp_range, printer_filament_type
			
 
				 
			
 
				 logger = logging.getLogger(__name__)
			
 
				 
			
@@ -100,14 +104,47 @@ async def get_spoolman_status(
 
				     db: AsyncSession = Depends(get_db),
			
 
				     _: User | None = RequirePermissionIfAuthEnabled(Permission.FILAMENTS_READ),
			
 
				 ):
			
 
				-    """Get Spoolman integration status."""
			
 
				+    """Get Spoolman integration status.
			
 
				+
			
 
				+    ``connected`` answers "does the configured Spoolman respond?", which means
			
 
				+    asking it. It used to answer "has some earlier request in this process left
			
 
				+    a client object lying around?" -- and roughly twenty call sites build one
			
 
				+    lazily, so the answer depended on which page happened to load first rather
			
 
				+    than on anything about Spoolman.
			
 
				+
			
 
				+    That mattered because the UI reads this one flag twice: it offers Connect
			
 
				+    only while disconnected, and the AMS sync section only while connected.
			
 
				+    Saving the Settings page initialises a client as a side effect of syncing
			
 
				+    locations, so enabling Spoolman there reported "connected" without anything
			
 
				+    having been set up, hiding the Connect button and revealing a sync that then
			
 
				+    failed on every slot (issue #2903). Registration no longer depends on that
			
 
				+    button, but the flag was still describing Bambuddy's memory rather than the
			
 
				+    integration, so it is now resolved the same way every other route resolves
			
 
				+    it -- including the stale-URL check, so editing the URL is not reported
			
 
				+    against the old host.
			
 
				+    """
			
 
				     sm = await get_spoolman_settings(db)
			
 
				     enabled, url = sm["enabled"], sm["url"]
			
 
				 
			
 
				-    client = await get_spoolman_client()
			
 
				     connected = False
			
 
				-    if client:
			
 
				-        connected = await client.health_check()
			
 
				+    if enabled and url:
			
 
				+        client = await get_spoolman_client()
			
 
				+        if not client or client.base_url != url.rstrip("/"):
			
 
				+            try:
			
 
				+                client = await init_spoolman_client(url)
			
 
				+            except ValueError as exc:
			
 
				+                logger.warning("Spoolman URL %r rejected by SSRF guard during status check: %s", url, exc)
			
 
				+                client = None
			
 
				+            except Exception as exc:
			
 
				+                # Every remaining way this can fail still answers the question:
			
 
				+                # replacing a client closes the previous one, and httpx's
			
 
				+                # aclose() is not guaranteed not to raise. A status poll that
			
 
				+                # 500s every 30 seconds is worse than one reporting what is
			
 
				+                # true either way -- that Spoolman could not be reached.
			
 
				+                logger.warning("Could not open a Spoolman client for %r during status check: %s", url, exc)
			
 
				+                client = None
			
 
				+        if client:
			
 
				+            connected = await client.health_check()
			
 
				 
			
 
				     return SpoolmanStatus(
			
 
				         enabled=enabled,
			
@@ -904,40 +941,79 @@ async def link_spool(
 
				 
			
 
				             mqtt_client = printer_manager.get_client(p_id)
			
 
				             if mqtt_client:
			
 
				-                tray_type = mapped.get("material") or ""
			
 
				+                # Spoolman's material is free text, so it arrives as whatever
			
 
				+                # the user typed there -- "PLA+", "PolyTerra PLA". The sub-brand
			
 
				+                # keeps that wording; the slot's type has to be one the printer
			
 
				+                # and the slicer know (issue #2902).
			
 
				+                material = mapped.get("material") or ""
			
 
				+                tray_type = printer_filament_type(material)
			
 
				                 brand = mapped.get("brand") or ""
			
 
				                 subtype = mapped.get("subtype") or ""
			
 
				                 if brand:
			
 
				-                    tray_sub_brands = f"{brand} {tray_type} {subtype}".strip()
			
 
				+                    tray_sub_brands = f"{brand} {material} {subtype}".strip()
			
 
				                 elif subtype:
			
 
				-                    tray_sub_brands = f"{tray_type} {subtype}".strip()
			
 
				+                    tray_sub_brands = f"{material} {subtype}".strip()
			
 
				                 else:
			
 
				-                    tray_sub_brands = tray_type
			
 
				+                    tray_sub_brands = material
			
 
				 
			
 
				                 tray_color = (mapped.get("rgba") or "808080FF").upper()
			
 
				                 if len(tray_color) == 6:
			
 
				                     tray_color = tray_color + "FF"
			
 
				 
			
 
				-                material_upper = tray_type.upper().strip()
			
 
				-                tray_info_idx = (
			
 
				-                    GENERIC_FILAMENT_IDS.get(material_upper)
			
 
				-                    or GENERIC_FILAMENT_IDS.get(material_upper.split("-")[0].split(" ")[0])
			
 
				-                    or ""
			
 
				-                )
			
 
				-                setting_id = ""
			
 
				-                temp_defaults = MATERIAL_TEMPS.get(material_upper, (200, 240))
			
 
				-                temp_min = mapped.get("nozzle_temp_min") or temp_defaults[0]
			
 
				-                temp_max = temp_defaults[1]
			
 
				-
			
 
				                 # Pull printer state via printer_manager (mqtt_client.printer_state
			
 
				                 # was a non-existent attribute — the hasattr check silently
			
 
				                 # returned None, defeating every state-based lookup below).
			
 
				                 state = printer_manager.get_status(p_id)
			
 
				-                nozzle_diameter = "0.4"
			
 
				-                if state and state.nozzles:
			
 
				-                    nd = state.nozzles[0].nozzle_diameter
			
 
				-                    if nd:
			
 
				-                        nozzle_diameter = nd
			
 
				+                slot_nozzle = resolve_slot_nozzle(state, a_id, t_id, printer_manager.get_model(p_id))
			
 
				+                nozzle_diameter = slot_nozzle.diameter
			
 
				+
			
 
				+                # Resolve the spool's own preset before falling back to a
			
 
				+                # generic material id. This path used to skip that entirely and
			
 
				+                # configure every linked slot as generic PLA/PETG, so a spool
			
 
				+                # with a preset set in inventory lost it the moment it was
			
 
				+                # linked by tag — the same defect #1713 fixed on the assign
			
 
				+                # path, in the function next door. The per-model override
			
 
				+                # cascade applies here for the same reason it does there: the
			
 
				+                # preset is bound to a printer model.
			
 
				+                slot_slicer_filament, slot_slicer_filament_name = await resolve_spoolman_preset(
			
 
				+                    db,
			
 
				+                    spoolman_spool_id=spool_id,
			
 
				+                    printer_model=printer_manager.get_model(p_id),
			
 
				+                    nozzle_diameter=nozzle_diameter,
			
 
				+                    fallback_filament=mapped.get("slicer_filament"),
			
 
				+                    fallback_name=mapped.get("slicer_filament_name"),
			
 
				+                )
			
 
				+                tray_info_idx, setting_id, sub_brand_override, type_override = await resolve_slicer_filament(
			
 
				+                    db=db,
			
 
				+                    current_user=None,
			
 
				+                    slicer_filament=slot_slicer_filament,
			
 
				+                    slicer_filament_name=slot_slicer_filament_name,
			
 
				+                    material=material,
			
 
				+                )
			
 
				+                if sub_brand_override:
			
 
				+                    tray_sub_brands = sub_brand_override
			
 
				+                if type_override:
			
 
				+                    tray_type = printer_filament_type(type_override)
			
 
				+
			
 
				+                # The spool's own wording is tried first and the reduced type
			
 
				+                # only as a further fallback, so a material that already
			
 
				+                # resolves keeps resolving to the same id: "PETG HF" has its
			
 
				+                # own generic preset (GFG96) that reducing it to "PETG" would
			
 
				+                # trade away for GFG99.
			
 
				+                material_upper = material.upper().strip()
			
 
				+                if not tray_info_idx:
			
 
				+                    tray_info_idx = (
			
 
				+                        GENERIC_FILAMENT_IDS.get(material_upper)
			
 
				+                        or GENERIC_FILAMENT_IDS.get(material_upper.split("-")[0].split(" ")[0])
			
 
				+                        or GENERIC_FILAMENT_IDS.get(tray_type.upper())
			
 
				+                        or ""
			
 
				+                    )
			
 
				+                if tray_info_idx and not setting_id:
			
 
				+                    setting_id = filament_id_to_setting_id(tray_info_idx)
			
 
				+
			
 
				+                temp_defaults = nozzle_temp_range(material, tray_type)
			
 
				+                temp_min = mapped.get("nozzle_temp_min") or temp_defaults[0]
			
 
				+                temp_max = temp_defaults[1]
			
 
				 
			
 
				                 kp_result = await db.execute(
			
 
				                     select(SpoolmanKProfile).where(
			
@@ -946,12 +1022,7 @@ async def link_spool(
 
				                     )
			
 
				                 )
			
 
				                 kp_rows = kp_result.scalars().all()
			
 
				-                slot_extruder = None
			
 
				-                if state and state.ams_extruder_map:
			
 
				-                    if a_id == 255:
			
 
				-                        slot_extruder = 1 - t_id
			
 
				-                    else:
			
 
				-                        slot_extruder = state.ams_extruder_map.get(str(a_id))
			
 
				+                slot_extruder = slot_nozzle.extruder
			
 
				 
			
 
				                 # Prefer exact extruder match, fall back to extruder-agnostic kp
			
 
				                 # for the same nozzle. Hard-skip on extruder mismatch silently
			
@@ -962,6 +1033,8 @@ async def link_spool(
 
				                 for kp in kp_rows:
			
 
				                     if kp.nozzle_diameter != nozzle_diameter or kp.cali_idx is None:
			
 
				                         continue
			
 
				+                    if not slot_nozzle.flow_matches(kp.nozzle_type):
			
 
				+                        continue
			
 
				                     if slot_extruder is not None and kp.extruder is not None and kp.extruder == slot_extruder:
			
 
				                         exact_kp = kp
			
 
				                         break
			
--- a/backend/app/api/routes/spoolman_inventory.py
+++ b/backend/app/api/routes/spoolman_inventory.py
@@ -38,10 +38,11 @@ from backend.app.core.websocket import ws_manager
 
				 from backend.app.models.ams_label import AmsLabel
			
 
				 from backend.app.models.printer import Printer
			
 
				 from backend.app.models.settings import Settings
			
 
				+from backend.app.models.spool_filament_preset import SpoolmanFilamentPreset
			
 
				 from backend.app.models.spoolman_k_profile import SpoolmanKProfile
			
 
				 from backend.app.models.spoolman_slot_assignment import SpoolmanSlotAssignment
			
 
				 from backend.app.models.user import User
			
 
				-from backend.app.schemas.spool import SpoolKProfileBase
			
 
				+from backend.app.schemas.spool import SpoolFilamentPresetBase, SpoolKProfileBase
			
 
				 from backend.app.schemas.spoolman import SpoolmanFilamentPatch, SpoolmanSlotAssignmentEnriched
			
 
				 from backend.app.services.location_service import (
			
 
				     enrich_spool_dicts_with_location_id,
			
@@ -50,6 +51,8 @@ from backend.app.services.location_service import (
 
				 )
			
 
				 from backend.app.services.printer_manager import printer_manager
			
 
				 from backend.app.services.slicer_filament_resolver import resolve_slicer_filament
			
 
				+from backend.app.services.slot_nozzle import resolve_slot_nozzle
			
 
				+from backend.app.services.spool_filament_preset import resolve_spoolman_preset
			
 
				 from backend.app.services.spoolman import (
			
 
				     SpoolmanClient,
			
 
				     SpoolmanClientError,
			
@@ -59,12 +62,13 @@ from backend.app.services.spoolman import (
 
				     init_spoolman_client,
			
 
				 )
			
 
				 from backend.app.services.spoolman_tracking import get_fallback_spool_tag_for_slot
			
 
				+from backend.app.utils.color_utils import spoolman_color_hex
			
 
				 from backend.app.utils.filament_ids import (
			
 
				     GENERIC_FILAMENT_IDS,
			
 
				-    MATERIAL_TEMPS,
			
 
				     filament_id_to_setting_id,
			
 
				     normalize_slicer_filament,
			
 
				 )
			
 
				+from backend.app.utils.filament_types import nozzle_temp_range, printer_filament_type
			
 
				 
			
 
				 logger = logging.getLogger(__name__)
			
 
				 
			
@@ -502,7 +506,10 @@ async def _resolve_filament_id(data: SpoolmanInventoryCreate, client: SpoolmanCl
 
				         return data.spoolman_filament_id
			
 
				     # Validator guarantees material is non-None when spoolman_filament_id is None
			
 
				     assert data.material is not None  # noqa: S101
			
 
				-    color_hex = (data.rgba or "808080FF")[:6]
			
 
				+    # `or "808080"` on the result rather than on the input: spoolman_color_hex
			
 
				+    # returns None only for a missing value, so this is the same neutral grey the
			
 
				+    # old inline default produced, without handing an Optional to a str parameter.
			
 
				+    color_hex = spoolman_color_hex(data.rgba) or "808080"
			
 
				     async with _translate_spoolman_errors():
			
 
				         return await client.find_or_create_filament(
			
 
				             material=data.material,
			
@@ -708,7 +715,10 @@ async def update_spool(
 
				     else:
			
 
				         color_name = cur_filament.get("color_name") or None
			
 
				     cur_color = (cur_filament.get("color_hex") or "808080").upper().removeprefix("#")
			
 
				-    rgba = data.rgba if data.rgba is not None else (cur_color + "FF")
			
 
				+    # Handed over as stored. The opaque alpha this used to append was folded
			
 
				+    # straight back off by `spoolman_color_hex` below, so the two paths landed on
			
 
				+    # the same string and the append only obscured which shape was in hand (#2912).
			
 
				+    rgba = data.rgba if data.rgba is not None else cur_color
			
 
				     label_weight = data.label_weight if data.label_weight is not None else int(cur_filament.get("weight") or 1000)
			
 
				     # Default weight_used from the synthetic mapping (label - remaining) so an
			
 
				     # edit that doesn't touch the weight field preserves Spoolman's real
			
@@ -736,7 +746,7 @@ async def update_spool(
 
				         except ValueError as exc:
			
 
				             raise HTTPException(status_code=400, detail=str(exc)) from exc
			
 
				 
			
 
				-    color_hex = rgba[:6]
			
 
				+    color_hex = spoolman_color_hex(rgba) or rgba
			
 
				 
			
 
				     # Resolve which filament this spool should be linked to AFTER the edit.
			
 
				     #
			
@@ -749,14 +759,18 @@ async def update_spool(
 
				     # filament in place when it's a singleton.
			
 
				     cur_filament_id = cur_filament.get("id")
			
 
				     desired_name = f"{material} {subtype}".strip() if subtype else material
			
 
				-    cur_color_norm = (cur_filament.get("color_hex") or "").upper()[:6]
			
 
				+    # Compare the stored shapes, not raw strings and not bare RGB prefixes. Raw
			
 
				+    # strings make an opaque spool's six characters differ from an incoming eight
			
 
				+    # and PATCH the filament on every no-op edit; bare prefixes make an
			
 
				+    # alpha-only edit invisible so the change never lands (#2912).
			
 
				+    cur_color_norm = spoolman_color_hex(cur_filament.get("color_hex")) or ""
			
 
				     cur_vendor_name = (cur_vendor.get("name") or "").strip()
			
 
				     cur_weight_int = int(cur_filament.get("weight") or 0)
			
 
				     metadata_unchanged = (
			
 
				         cur_filament_id
			
 
				         and (cur_filament.get("name") or "").strip() == desired_name
			
 
				         and (cur_filament.get("material") or "").upper() == material.upper()
			
 
				-        and cur_color_norm == color_hex.upper()
			
 
				+        and cur_color_norm == (color_hex or "").upper()
			
 
				         and cur_vendor_name.lower() == ((brand or "").strip().lower())
			
 
				         and cur_weight_int == int(label_weight)
			
 
				     )
			
@@ -1477,20 +1491,52 @@ async def assign_spoolman_slot(
 
				     try:
			
 
				         mqtt_client = printer_manager.get_client(body.printer_id)
			
 
				         if mqtt_client:
			
 
				-            tray_type = mapped.get("material") or ""
			
 
				+            # Spoolman's material is free text, so it arrives as whatever the
			
 
				+            # user typed there -- "PLA+", "PolyTerra PLA". The sub-brand keeps
			
 
				+            # that wording; the slot's type has to be one the printer and the
			
 
				+            # slicer know (issue #2902).
			
 
				+            material = mapped.get("material") or ""
			
 
				+            tray_type = printer_filament_type(material)
			
 
				             brand = mapped.get("brand") or ""
			
 
				             subtype = mapped.get("subtype") or ""
			
 
				             if brand:
			
 
				-                tray_sub_brands = f"{brand} {tray_type} {subtype}".strip()
			
 
				+                tray_sub_brands = f"{brand} {material} {subtype}".strip()
			
 
				             elif subtype:
			
 
				-                tray_sub_brands = f"{tray_type} {subtype}".strip()
			
 
				+                tray_sub_brands = f"{material} {subtype}".strip()
			
 
				             else:
			
 
				-                tray_sub_brands = tray_type
			
 
				+                tray_sub_brands = material
			
 
				 
			
 
				             tray_color = (mapped.get("rgba") or "808080FF").upper()
			
 
				             if len(tray_color) == 6:
			
 
				                 tray_color = tray_color + "FF"
			
 
				 
			
 
				+            # Printer state, read here rather than further down because the
			
 
				+            # per-model preset override below needs the slot's nozzle
			
 
				+            # diameter and the K-profile cascade further down needs the same
			
 
				+            # value -- one read, so they cannot disagree. (The previous
			
 
				+            # `mqtt_client.printer_state` access via hasattr always returned
			
 
				+            # None -- the attribute is `state`, not `printer_state` -- so the
			
 
				+            # K-profile cascade silently skipped state.kprofiles, defaulted
			
 
				+            # nozzle_diameter to 0.4, and left slot_extruder unset.)
			
 
				+            state = printer_manager.get_status(body.printer_id)
			
 
				+            slot_nozzle = resolve_slot_nozzle(
			
 
				+                state, body.ams_id, body.tray_id, printer_manager.get_model(body.printer_id)
			
 
				+            )
			
 
				+            nozzle_diameter = slot_nozzle.diameter
			
 
				+
			
 
				+            # Per-printer-model preset override, same cascade as internal
			
 
				+            # mode: a cloud/Orca preset is bound to a model, so one stored
			
 
				+            # preset per spool is wrong across two models. Returns Spoolman's
			
 
				+            # own value when no override is set.
			
 
				+            slot_slicer_filament, slot_slicer_filament_name = await resolve_spoolman_preset(
			
 
				+                db,
			
 
				+                spoolman_spool_id=body.spoolman_spool_id,
			
 
				+                printer_model=printer_manager.get_model(body.printer_id),
			
 
				+                nozzle_diameter=nozzle_diameter,
			
 
				+                fallback_filament=mapped.get("slicer_filament"),
			
 
				+                fallback_name=mapped.get("slicer_filament_name"),
			
 
				+            )
			
 
				+
			
 
				             # #1713: resolve the spool's stored slicer_filament reference
			
 
				             # (cloud preset, local preset, GF-prefix builtin, or numeric
			
 
				             # LocalPreset id) to the printer-side tray_info_idx + setting_id.
			
@@ -1499,24 +1545,33 @@ async def assign_spoolman_slot(
 
				             # configured profile never reached the printer. Shared with the
			
 
				             # internal-mode route via the same helper so the two flows can't
			
 
				             # drift again.
			
 
				-            tray_info_idx, setting_id, sub_brand_override = await resolve_slicer_filament(
			
 
				+            tray_info_idx, setting_id, sub_brand_override, type_override = await resolve_slicer_filament(
			
 
				                 db=db,
			
 
				                 current_user=current_user,
			
 
				-                slicer_filament=mapped.get("slicer_filament"),
			
 
				-                slicer_filament_name=mapped.get("slicer_filament_name"),
			
 
				-                material=tray_type,
			
 
				+                slicer_filament=slot_slicer_filament,
			
 
				+                slicer_filament_name=slot_slicer_filament_name,
			
 
				+                material=material,
			
 
				             )
			
 
				             if sub_brand_override:
			
 
				                 tray_sub_brands = sub_brand_override
			
 
				+            # A preset carries its own type; the reduction above only infers
			
 
				+            # one from Spoolman's free-text material. The preset wins when the
			
 
				+            # spool has one (issue #2902, @doncaruana).
			
 
				+            if type_override:
			
 
				+                tray_type = printer_filament_type(type_override)
			
 
				 
			
 
				-            material_upper = tray_type.upper().strip()
			
 
				+            material_upper = material.upper().strip()
			
 
				             # Fall back to generic-material id when slicer_filament is empty
			
 
				             # or the resolver discarded an unresolvable value. Matches the
			
 
				-            # internal-mode tail in inventory.py:_apply_spool_to_slot_inner.
			
 
				+            # internal-mode tail in inventory.py:_apply_spool_to_slot_inner,
			
 
				+            # including the order: the spool's own wording first and the
			
 
				+            # reduced type only after it, so "PETG HF" keeps its own generic
			
 
				+            # preset (GFG96) rather than trading it for "PETG"'s GFG99.
			
 
				             if not tray_info_idx:
			
 
				                 tray_info_idx = (
			
 
				                     GENERIC_FILAMENT_IDS.get(material_upper)
			
 
				                     or GENERIC_FILAMENT_IDS.get(material_upper.split("-")[0].split(" ")[0])
			
 
				+                    or GENERIC_FILAMENT_IDS.get(tray_type.upper())
			
 
				                     or ""
			
 
				                 )
			
 
				 
			
@@ -1529,7 +1584,7 @@ async def assign_spoolman_slot(
 
				             if tray_info_idx and not setting_id:
			
 
				                 setting_id = filament_id_to_setting_id(tray_info_idx)
			
 
				 
			
 
				-            temp_defaults = MATERIAL_TEMPS.get(material_upper, (200, 240))
			
 
				+            temp_defaults = nozzle_temp_range(material, tray_type)
			
 
				             temp_min = mapped.get("nozzle_temp_min") or temp_defaults[0]
			
 
				             temp_max = temp_defaults[1]
			
 
				 
			
@@ -1538,21 +1593,7 @@ async def assign_spoolman_slot(
 
				             # None (the attribute is `state`, not `printer_state`), so the
			
 
				             # K-profile cascade silently skipped state.kprofiles, defaulted
			
 
				             # nozzle_diameter to 0.4, and left slot_extruder unset.
			
 
				-            state = printer_manager.get_status(body.printer_id)
			
 
				-            nozzle_diameter = "0.4"
			
 
				-            if state and state.nozzles:
			
 
				-                nd = state.nozzles[0].nozzle_diameter
			
 
				-                if nd:
			
 
				-                    nozzle_diameter = nd
			
 
				-
			
 
				-            slot_extruder = None
			
 
				-            if state and state.ams_extruder_map:
			
 
				-                if body.ams_id == 255:
			
 
				-                    # External slots: ext-L (tray 0) → extruder 1, ext-R (tray 1) → extruder 0
			
 
				-                    # tray_id 0→1, 1→0
			
 
				-                    slot_extruder = 1 - body.tray_id
			
 
				-                else:
			
 
				-                    slot_extruder = state.ams_extruder_map.get(str(body.ams_id))
			
 
				+            slot_extruder = slot_nozzle.extruder
			
 
				 
			
 
				             # Prefer exact extruder match, fall back to extruder-agnostic kp
			
 
				             # for the same nozzle. Hard-skipping on mismatch silently dropped
			
@@ -1562,6 +1603,8 @@ async def assign_spoolman_slot(
 
				             for kp in kp_rows:
			
 
				                 if kp.nozzle_diameter != nozzle_diameter or kp.cali_idx is None:
			
 
				                     continue
			
 
				+                if not slot_nozzle.flow_matches(kp.nozzle_type):
			
 
				+                    continue
			
 
				                 if slot_extruder is not None and kp.extruder is not None and kp.extruder == slot_extruder:
			
 
				                     exact_kp = kp
			
 
				                     break
			
@@ -1795,6 +1838,89 @@ def _k_profile_to_dict(p: SpoolmanKProfile) -> dict:
 
				     }
			
 
				 
			
 
				 
			
 
				+def _filament_preset_to_dict(p: SpoolmanFilamentPreset) -> dict:
			
 
				+    """Manually map SpoolmanFilamentPreset → SpoolFilamentPresetResponse-compatible dict."""
			
 
				+    return {
			
 
				+        "id": p.id,
			
 
				+        "spool_id": p.spoolman_spool_id,
			
 
				+        "printer_model": p.printer_model,
			
 
				+        "nozzle_diameter": p.nozzle_diameter,
			
 
				+        "slicer_filament": p.slicer_filament,
			
 
				+        "slicer_filament_name": p.slicer_filament_name,
			
 
				+        "created_at": p.created_at,
			
 
				+    }
			
 
				+
			
 
				+
			
 
				+@router.get("/spools/{spool_id}/filament-presets")
			
 
				+async def get_spoolman_filament_presets(
			
 
				+    spool_id: int = Path(..., gt=0),
			
 
				+    db: AsyncSession = Depends(get_db),
			
 
				+    _: User | None = RequirePermissionIfAuthEnabled(Permission.INVENTORY_READ),
			
 
				+) -> list[dict]:
			
 
				+    """Return all per-printer-model preset overrides for a Spoolman spool."""
			
 
				+    await _get_client(db)
			
 
				+    result = await db.execute(
			
 
				+        select(SpoolmanFilamentPreset).where(SpoolmanFilamentPreset.spoolman_spool_id == spool_id)
			
 
				+    )
			
 
				+    return [_filament_preset_to_dict(p) for p in result.scalars().all()]
			
 
				+
			
 
				+
			
 
				+@router.put("/spools/{spool_id}/filament-presets")
			
 
				+async def save_spoolman_filament_presets(
			
 
				+    spool_id: int = Path(..., gt=0),
			
 
				+    presets: list[SpoolFilamentPresetBase] = Body(...),
			
 
				+    db: AsyncSession = Depends(get_db),
			
 
				+    _: User | None = RequirePermissionIfAuthEnabled(Permission.INVENTORY_UPDATE),
			
 
				+) -> list[dict]:
			
 
				+    """Replace all per-printer-model preset overrides for a Spoolman spool."""
			
 
				+    client = await _get_client(db)
			
 
				+    async with _translate_spoolman_errors():
			
 
				+        await client.get_spool(spool_id)
			
 
				+
			
 
				+    # Same as the internal route: reject a duplicated (model, diameter) before
			
 
				+    # touching the stored rows, so a bad payload cannot clear what it fails to
			
 
				+    # replace.
			
 
				+    seen: set[tuple[str, str]] = set()
			
 
				+    for preset in presets:
			
 
				+        key = (preset.printer_model, preset.nozzle_diameter)
			
 
				+        if key in seen:
			
 
				+            raise HTTPException(
			
 
				+                422,
			
 
				+                f"Duplicate override for model {preset.printer_model!r} nozzle {preset.nozzle_diameter or 'any'!r}",
			
 
				+            )
			
 
				+        seen.add(key)
			
 
				+
			
 
				+    saved: list[SpoolmanFilamentPreset] = []
			
 
				+    try:
			
 
				+        await db.execute(delete(SpoolmanFilamentPreset).where(SpoolmanFilamentPreset.spoolman_spool_id == spool_id))
			
 
				+        await db.flush()
			
 
				+        for preset in presets:
			
 
				+            obj = SpoolmanFilamentPreset(
			
 
				+                spoolman_spool_id=spool_id,
			
 
				+                printer_model=preset.printer_model,
			
 
				+                nozzle_diameter=preset.nozzle_diameter,
			
 
				+                slicer_filament=preset.slicer_filament,
			
 
				+                slicer_filament_name=preset.slicer_filament_name,
			
 
				+            )
			
 
				+            db.add(obj)
			
 
				+            saved.append(obj)
			
 
				+        await db.commit()
			
 
				+    except IntegrityError as exc:
			
 
				+        await db.rollback()
			
 
				+        raise HTTPException(422, "Duplicate or invalid preset override (check model and nozzle uniqueness)") from exc
			
 
				+    except HTTPException:
			
 
				+        raise
			
 
				+    except Exception as exc:
			
 
				+        await db.rollback()
			
 
				+        logger.error("Filament preset save for spool %d failed: %s", spool_id, exc)
			
 
				+        raise HTTPException(500, "Failed to save filament presets") from exc
			
 
				+
			
 
				+    for obj in saved:
			
 
				+        await db.refresh(obj)
			
 
				+
			
 
				+    return [_filament_preset_to_dict(p) for p in saved]
			
 
				+
			
 
				+
			
 
				 def _normalize_filament(raw: dict) -> NormalizedFilament | None:
			
 
				     """Normalise a raw Spoolman filament dict for the frontend catalog picker.
			
 
				 
			
--- a/backend/app/api/routes/support.py
+++ b/backend/app/api/routes/support.py
@@ -42,6 +42,7 @@ from backend.app.services.log_reader import (
 
				 )
			
 
				 from backend.app.services.network_utils import get_network_interfaces
			
 
				 from backend.app.services.printer_manager import printer_manager
			
 
				+from backend.app.utils.local_time import utcnow_naive
			
 
				 
			
 
				 router = APIRouter(prefix="/support", tags=["support"])
			
 
				 logger = logging.getLogger(__name__)
			
@@ -596,9 +597,12 @@ async def _collect_queue_info(db: AsyncSession) -> dict:
 
				         )
			
 
				     ).scalar_one_or_none()
			
 
				     if oldest_row is not None:
			
 
				-        # created_at is naive in this codebase (server_default=func.now()); compare
			
 
				-        # against naive utc-now to get the actual age without TZ-conversion surprises.
			
 
				-        age = (datetime.now() - oldest_row).total_seconds()
			
 
				+        # created_at is naive in this codebase (server_default=func.now()) and holds
			
 
				+        # UTC, so the clock on the other side of the subtraction has to be naive UTC
			
 
				+        # too. datetime.now() is naive *local*: on a UTC+3 host it reported an item
			
 
				+        # queued five minutes ago as three hours old, and went negative west of
			
 
				+        # Greenwich (#2855).
			
 
				+        age = (utcnow_naive() - oldest_row).total_seconds()
			
 
				         info["oldest_pending_age_seconds"] = int(age)
			
 
				     else:
			
 
				         info["oldest_pending_age_seconds"] = None
			
--- a/backend/app/core/auth.py
+++ b/backend/app/core/auth.py
@@ -4,6 +4,7 @@ import logging
 
				 import os
			
 
				 import secrets
			
 
				 import time
			
 
				+from contextvars import ContextVar
			
 
				 from datetime import datetime, timedelta, timezone
			
 
				 from typing import Annotated
			
 
				 
			
@@ -1129,6 +1130,15 @@ async def _user_from_api_key(db: AsyncSession, api_key: APIKey) -> User | None:
 
				     return user
			
 
				 
			
 
				 
			
 
				+# The row a successful validation produced for the request in flight. Printer-
			
 
				+# scoped routes validate the same credential twice -- once in the permission
			
 
				+# gate, once for the key's printer allowlist -- and a validation is a pbkdf2
			
 
				+# verify plus a ``last_used`` write, so the second one is pure cost. Keyed by
			
 
				+# the raw credential so a request carrying two of them can never cross their
			
 
				+# rows, and held in a ContextVar so it cannot outlive the task that set it.
			
 
				+_validated_api_key: ContextVar[tuple[str, APIKey] | None] = ContextVar("_validated_api_key", default=None)
			
 
				+
			
 
				+
			
 
				 async def _validate_api_key(db: AsyncSession, api_key_value: str) -> APIKey | None:
			
 
				     """Validate an API key and return the APIKey object if valid, None otherwise.
			
 
				 
			
@@ -1163,6 +1173,7 @@ async def _validate_api_key(db: AsyncSession, api_key_value: str) -> APIKey | No
 
				                 # Update last_used timestamp
			
 
				                 api_key.last_used = datetime.now(timezone.utc)
			
 
				                 await db.commit()
			
 
				+                _validated_api_key.set((api_key_value, api_key))
			
 
				                 return api_key
			
 
				     except Exception as e:  # SEC-AUTH-EXC: validation failure returns None; every caller treats None as "invalid key" → 401 (fail-closed)
			
 
				         logger.warning("API key validation error: %s", e)
			
@@ -1625,6 +1636,67 @@ def check_printer_access(api_key: APIKey, printer_id: int) -> None:
 
				         )
			
 
				 
			
 
				 
			
 
				+async def validated_api_key_from_request(
			
 
				+    credentials: HTTPAuthorizationCredentials | None,
			
 
				+    x_api_key: str | None,
			
 
				+) -> APIKey | None:
			
 
				+    """Return the validated API key carried by a request, if any.
			
 
				+
			
 
				+    Permission dependencies intentionally return ``None`` for API-key callers so
			
 
				+    routes do not mistake a key for a user identity. Printer-bound routes still
			
 
				+    need the key row to enforce ``printer_ids`` after the normal scope/owner
			
 
				+    permission gate has run. This helper recognizes both supported transports.
			
 
				+    """
			
 
				+
			
 
				+    candidate = x_api_key
			
 
				+    if candidate is None and credentials is not None and credentials.credentials.startswith("bb_"):
			
 
				+        candidate = credentials.credentials
			
 
				+    if candidate is None:
			
 
				+        return None
			
 
				+    cached = _validated_api_key.get()
			
 
				+    if cached is not None and cached[0] == candidate:
			
 
				+        return cached[1]
			
 
				+    async with async_session() as db:
			
 
				+        api_key = await _validate_api_key(db, candidate)
			
 
				+        if api_key is None:
			
 
				+            raise HTTPException(
			
 
				+                status_code=status.HTTP_401_UNAUTHORIZED,
			
 
				+                detail="Invalid API key",
			
 
				+                headers={"WWW-Authenticate": "Bearer"},
			
 
				+            )
			
 
				+        # Touch the JSON-backed value before detaching the row from the session.
			
 
				+        _ = api_key.printer_ids
			
 
				+        return api_key
			
 
				+
			
 
				+
			
 
				+async def current_api_key_if_present(
			
 
				+    credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(security)] = None,
			
 
				+    x_api_key: Annotated[str | None, Header(alias="X-API-Key")] = None,
			
 
				+) -> APIKey | None:
			
 
				+    """FastAPI dependency exposing only an authenticated API-key principal."""
			
 
				+
			
 
				+    return await validated_api_key_from_request(credentials, x_api_key)
			
 
				+
			
 
				+
			
 
				+def require_printer_permission_if_auth_enabled(permission: str | Permission):
			
 
				+    """Require a permission and enforce an API key's per-printer allowlist."""
			
 
				+
			
 
				+    permission_checker = require_permission_if_auth_enabled(permission)
			
 
				+
			
 
				+    async def checker(
			
 
				+        printer_id: int,
			
 
				+        credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(security)] = None,
			
 
				+        x_api_key: Annotated[str | None, Header(alias="X-API-Key")] = None,
			
 
				+    ) -> User | None:
			
 
				+        user = await permission_checker(credentials=credentials, x_api_key=x_api_key)
			
 
				+        api_key = await validated_api_key_from_request(credentials, x_api_key)
			
 
				+        if api_key is not None:
			
 
				+            check_printer_access(api_key, printer_id)
			
 
				+        return user
			
 
				+
			
 
				+    return checker
			
 
				+
			
 
				+
			
 
				 # Convenience dependencies - these are functions that return Depends objects
			
 
				 def RequireAdmin():
			
 
				     """Dependency that requires admin role."""
			
@@ -1834,6 +1906,37 @@ def RequirePermissionIfAuthEnabled(*permissions: str | Permission):
 
				     return Depends(require_permission_if_auth_enabled(*permissions))
			
 
				 
			
 
				 
			
 
				+def RequirePrinterPermissionIfAuthEnabled(permission: str | Permission):
			
 
				+    """Require a permission plus any API-key ``printer_ids`` restriction."""
			
 
				+
			
 
				+    return Depends(require_printer_permission_if_auth_enabled(permission))
			
 
				+
			
 
				+
			
 
				+def probe_permissions_if_auth_enabled(*permissions: str | Permission):
			
 
				+    """Return permission availability while preserving authentication errors.
			
 
				+
			
 
				+    This is for endpoints that can return a useful permission-independent
			
 
				+    subset. Missing permissions become ``False``; invalid or absent credentials
			
 
				+    still retain the normal 401 response from the shared permission checker.
			
 
				+    """
			
 
				+
			
 
				+    permission_checker = require_permission_if_auth_enabled(*permissions)
			
 
				+
			
 
				+    async def checker(
			
 
				+        credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(security)] = None,
			
 
				+        x_api_key: Annotated[str | None, Header(alias="X-API-Key")] = None,
			
 
				+    ) -> bool:
			
 
				+        try:
			
 
				+            await permission_checker(credentials, x_api_key)
			
 
				+        except HTTPException as exc:
			
 
				+            if exc.status_code == status.HTTP_403_FORBIDDEN:
			
 
				+                return False
			
 
				+            raise
			
 
				+        return True
			
 
				+
			
 
				+    return checker
			
 
				+
			
 
				+
			
 
				 def require_any_permission_if_auth_enabled(*permissions: str | Permission):
			
 
				     """Dependency factory that requires AT LEAST ONE of the given permissions when auth is enabled."""
			
 
				     perm_strings = [p.value if isinstance(p, Permission) else p for p in permissions]
			
--- a/backend/app/core/config.py
+++ b/backend/app/core/config.py
@@ -7,7 +7,7 @@ from pydantic import Field
 
				 from pydantic_settings import BaseSettings
			
 
				 
			
 
				 # Application version - single source of truth
			
 
				-APP_VERSION = "1.2.5.3"
			
 
				+APP_VERSION = "1.2.5.4"
			
 
				 GITHUB_REPO = "maziggy/bambuddy"
			
 
				 BUG_REPORT_RELAY_URL = os.environ.get("BUG_REPORT_RELAY_URL", "https://bambuddy.cool/api/bug-report")
			
 
				 
			
--- a/backend/app/core/database.py
+++ b/backend/app/core/database.py
@@ -65,9 +65,43 @@ def _resolve_pool_kwargs() -> dict:
 
				     return kwargs
			
 
				 
			
 
				 
			
 
				+def _resolve_connect_args() -> dict:
			
 
				+    """Connect args that pin a PostgreSQL session to UTC (issue #2855).
			
 
				+
			
 
				+    Bambuddy's ``DateTime`` columns are naive and hold UTC, and the frontend's
			
 
				+    ``parseUTCDate()`` reads a timestamp with no offset as UTC. Python-side
			
 
				+    writes honour that (``utcnow_naive()``), but ~96 columns take their value
			
 
				+    from ``server_default=func.now()`` and the migration DDL has ~49 more on
			
 
				+    ``DEFAULT CURRENT_TIMESTAMP`` — those are filled by the database, not by us.
			
 
				+
			
 
				+    On PostgreSQL ``now()`` is a ``timestamptz``, so storing it into a
			
 
				+    ``timestamp without time zone`` column casts it through the session
			
 
				+    ``TimeZone``. A Postgres container started with ``TZ=Europe/Istanbul`` bakes
			
 
				+    that zone into ``postgresql.conf`` at initdb, and every defaulted timestamp
			
 
				+    is then written as local wall-clock and rendered three hours in the future.
			
 
				+    Pinning the session makes the cast a no-op regardless of the server's own
			
 
				+    setting.
			
 
				+
			
 
				+    SQLite needs nothing: its ``CURRENT_TIMESTAMP`` is UTC by definition and has
			
 
				+    no session timezone to get wrong. This makes Postgres match SQLite rather
			
 
				+    than introducing a third convention.
			
 
				+    """
			
 
				+    if is_sqlite():
			
 
				+        return {}
			
 
				+    # asyncpg is the documented driver and sends these in the startup packet;
			
 
				+    # anything else Postgres goes through libpq, which takes the same setting
			
 
				+    # as a command-line option.
			
 
				+    if "+asyncpg" in settings.database_url:
			
 
				+        return {"server_settings": {"timezone": "UTC"}}
			
 
				+    return {"options": "-c timezone=UTC"}
			
 
				+
			
 
				+
			
 
				 def _create_engine():
			
 
				     """Create the async engine with dialect-appropriate settings."""
			
 
				     kwargs = _resolve_pool_kwargs()
			
 
				+    connect_args = _resolve_connect_args()
			
 
				+    if connect_args:
			
 
				+        kwargs["connect_args"] = connect_args
			
 
				 
			
 
				     global _pool_config
			
 
				     _pool_config = {
			
@@ -269,6 +303,7 @@ async def init_db():
 
				         library,
			
 
				         local_preset,
			
 
				         location,
			
 
				+        location_ha_sensor,
			
 
				         long_lived_token,
			
 
				         maintenance,
			
 
				         notification,
			
@@ -285,6 +320,7 @@ async def init_db():
 
				         printer_sensor_history,
			
 
				         project,
			
 
				         project_bom,
			
 
				+        scheduled_drying,
			
 
				         settings,
			
 
				         shopping_list,
			
 
				         slicer_pipeline,
			
@@ -294,6 +330,7 @@ async def init_db():
 
				         spool,
			
 
				         spool_assignment,
			
 
				         spool_catalog,
			
 
				+        spool_filament_preset,
			
 
				         spool_k_profile,
			
 
				         spool_usage_history,
			
 
				         spoolbuddy_device,
			
@@ -559,16 +596,64 @@ async def _migrate_encrypt_legacy_secrets() -> None:
 
				         )
			
 
				 
			
 
				 
			
 
				+# PostgreSQL SQLSTATE codes meaning "this DDL statement has already been applied".
			
 
				+# We classify on these rather than on the error text because the server renders
			
 
				+# messages in its own ``lc_messages`` locale: a Russian-locale server answers a
			
 
				+# duplicate ADD COLUMN with "уже существует", which no English substring check can
			
 
				+# recognise. That made Bambuddy unstartable on every non-English PostgreSQL server,
			
 
				+# fresh or existing — create_all() runs before run_migrations(), so on a new database
			
 
				+# essentially every ADD COLUMN below is expected to come back as a duplicate (#2949).
			
 
				+_PG_ALREADY_APPLIED = frozenset(
			
 
				+    {
			
 
				+        "42701",  # duplicate_column — ALTER TABLE ADD COLUMN
			
 
				+        "42P07",  # duplicate_table — CREATE TABLE, CREATE INDEX
			
 
				+        "42710",  # duplicate_object — ADD CONSTRAINT, CREATE TRIGGER
			
 
				+        "23505",  # unique_violation — duplicate key
			
 
				+    }
			
 
				+)
			
 
				+
			
 
				+# undefined_column. Idempotency only for RENAME COLUMN (the rename already ran);
			
 
				+# on any other statement a missing column means a broken schema, not a re-run.
			
 
				+_PG_UNDEFINED_COLUMN = "42703"
			
 
				+
			
 
				+
			
 
				+def _sqlstate(exc) -> str | None:
			
 
				+    """Return the PostgreSQL SQLSTATE behind a SQLAlchemy error, or None.
			
 
				+
			
 
				+    None on SQLite, whose DBAPI exceptions carry no such code — and which never
			
 
				+    localises its messages, so the text match below stays correct there.
			
 
				+    """
			
 
				+    orig = getattr(exc, "orig", None)
			
 
				+    for attr in ("sqlstate", "pgcode"):
			
 
				+        code = getattr(orig, attr, None)
			
 
				+        if code:
			
 
				+            return str(code)
			
 
				+    return None
			
 
				+
			
 
				+
			
 
				+def _is_already_applied(exc, sql: str) -> bool:
			
 
				+    """Return True if a failed DDL statement had simply already been applied."""
			
 
				+    is_rename = "rename column" in sql.lower()
			
 
				+
			
 
				+    state = _sqlstate(exc)
			
 
				+    if state is not None:
			
 
				+        return state in _PG_ALREADY_APPLIED or (state == _PG_UNDEFINED_COLUMN and is_rename)
			
 
				+
			
 
				+    msg = str(exc).lower()
			
 
				+    if any(k in msg for k in ("already exists", "duplicate key", "duplicate column name", "no such column")):
			
 
				+        return True
			
 
				+    return is_rename and "column" in msg and "does not exist" in msg
			
 
				+
			
 
				+
			
 
				 async def _safe_execute(conn, sql):
			
 
				     """Execute a DDL migration statement, silently ignoring idempotency errors.
			
 
				 
			
 
				-    'already exists', 'duplicate column name' (SQLite ADD COLUMN), 'no such column'
			
 
				-    (SQLite RENAME COLUMN), 'duplicate key', and the compound
			
 
				-    'column … does not exist' (PostgreSQL RENAME COLUMN idempotency) are swallowed
			
 
				-    so that re-running DDL migrations is safe.  The compound check additionally
			
 
				-    requires the SQL to be a RENAME COLUMN statement so that "does not exist" errors
			
 
				-    from ADD COLUMN or CREATE INDEX (which would indicate schema corruption, not
			
 
				-    idempotency) are never silently swallowed.
			
 
				+    Statements that had already been applied are swallowed so that re-running DDL
			
 
				+    migrations is safe — see :func:`_is_already_applied` for how that is decided
			
 
				+    (SQLSTATE on PostgreSQL, message text on SQLite). Idempotency for a missing
			
 
				+    column is narrowed to RENAME COLUMN, so a missing column on ADD COLUMN or
			
 
				+    CREATE INDEX — which would indicate schema corruption, not a re-run — is never
			
 
				+    silently swallowed.
			
 
				     Any other error is logged and re-raised — callers must not assume silent
			
 
				     recovery, as a failure will abort the migration sequence and prevent
			
 
				     application startup.
			
@@ -586,14 +671,7 @@ async def _safe_execute(conn, sql):
 
				         async with conn.begin_nested():
			
 
				             await conn.execute(text(sql))
			
 
				     except (OperationalError, ProgrammingError) as exc:
			
 
				-        msg = str(exc).lower()
			
 
				-        # Only swallow "column … does not exist" for RENAME COLUMN — not for ADD COLUMN
			
 
				-        # or CREATE INDEX where it would indicate schema corruption, not idempotency.
			
 
				-        column_not_exists = "rename column" in sql.lower() and "column" in msg and "does not exist" in msg
			
 
				-        if (
			
 
				-            not any(k in msg for k in ("already exists", "duplicate key", "duplicate column name", "no such column"))
			
 
				-            and not column_not_exists
			
 
				-        ):
			
 
				+        if not _is_already_applied(exc, sql):
			
 
				             logger.error("Migration statement failed: %s | SQL: %.200s", exc, sql)
			
 
				             raise
			
 
				 
			
@@ -809,6 +887,168 @@ async def _migrate_scope_run_filament_to_plate(conn) -> None:
 
				         )
			
 
				 
			
 
				 
			
 
				+async def _reclassify_sliced_3mf_library_files(conn) -> None:
			
 
				+    """Re-type library rows holding a sliced 3MF that does not say so (#2993).
			
 
				+
			
 
				+    ``file_type`` was decided from the filename alone, so a sliced 3MF whose
			
 
				+    name lacks the ``.gcode`` infix landed as a source-only project. That is
			
 
				+    not a rare shape: a plate exported from Studio, or a print dispatched
			
 
				+    through the cloud, reaches the archive as ``Foo.3mf`` with its G-code
			
 
				+    intact, and downloading one and re-importing it produced a library file
			
 
				+    Bambuddy refused to offer a Print button for. The forward fix classifies on
			
 
				+    content; this pass reaches the rows already stored.
			
 
				+
			
 
				+    One-shot, for the same reason the #2614 backfill is: a genuine source 3MF
			
 
				+    keeps matching ``file_type = '3mf'`` forever, so without the gate every
			
 
				+    boot would re-open every model file in the library.
			
 
				+
			
 
				+    External rows are deliberately skipped. They point at a mount that may be
			
 
				+    slow, unmounted, or enormous, and startup is the worst possible place to
			
 
				+    find that out -- the folder's own scan re-types them with no such risk.
			
 
				+    """
			
 
				+    from pathlib import Path
			
 
				+
			
 
				+    from sqlalchemy import text
			
 
				+
			
 
				+    from backend.app.utils.threemf_tools import carries_gcode
			
 
				+
			
 
				+    flag = "_backfill_2993_sliced_3mf_type_done"
			
 
				+
			
 
				+    async with conn.begin_nested():
			
 
				+        already = (
			
 
				+            await conn.execute(text('SELECT value FROM settings WHERE "key" = :k'), {"k": flag})
			
 
				+        ).scalar_one_or_none()
			
 
				+        if already:
			
 
				+            return
			
 
				+
			
 
				+        rows = (
			
 
				+            await conn.execute(
			
 
				+                text(
			
 
				+                    "SELECT id, file_path FROM library_files "
			
 
				+                    "WHERE file_type = '3mf' AND deleted_at IS NULL "
			
 
				+                    "AND file_path IS NOT NULL AND file_path <> '' "
			
 
				+                    "AND (is_external IS NULL OR is_external = :false_val)"
			
 
				+                ),
			
 
				+                {"false_val": False},
			
 
				+            )
			
 
				+        ).fetchall()
			
 
				+
			
 
				+        reclassified = 0
			
 
				+        for row in rows:
			
 
				+            path = Path(row.file_path)
			
 
				+            if not path.is_absolute():
			
 
				+                path = settings.base_dir / row.file_path
			
 
				+            # carries_gcode swallows a missing or unreadable file, so a library
			
 
				+            # with holes in it still finishes the pass.
			
 
				+            if not carries_gcode(path):
			
 
				+                continue
			
 
				+            await conn.execute(
			
 
				+                text("UPDATE library_files SET file_type = 'gcode.3mf' WHERE id = :id"),
			
 
				+                {"id": row.id},
			
 
				+            )
			
 
				+            reclassified += 1
			
 
				+
			
 
				+        if reclassified:
			
 
				+            logger.info(
			
 
				+                "[#2993] Re-typed %d library file(s) from source 3MF to sliced -- they carry G-code",
			
 
				+                reclassified,
			
 
				+            )
			
 
				+
			
 
				+        # Marked done even when nothing matched, so the scan never repeats.
			
 
				+        await conn.execute(
			
 
				+            text('INSERT INTO settings ("key", value) VALUES (:k, :v)'),
			
 
				+            {"k": flag, "v": "true"},
			
 
				+        )
			
 
				+
			
 
				+
			
 
				+async def _backfill_archive_bed_temperature(conn) -> None:
			
 
				+    """Fill in ``print_archives.bed_temperature`` for archives written before #2989.
			
 
				+
			
 
				+    Bed temperature was read by looking for a ``bed_temperature`` key, which
			
 
				+    BambuStudio does not write -- it stores a per-filament array per plate type
			
 
				+    and names the fitted plate in ``curr_bed_type``. Every archive from a Bambu
			
 
				+    slice therefore stored NULL: 0 of 455 real 3MFs resolved on the install this
			
 
				+    was measured on. The forward fix reads the right array; without this, every
			
 
				+    archive made before it stays blank, and preheat keeps falling back to the
			
 
				+    keep-warm bed temperature when those jobs are reprinted from the queue.
			
 
				+
			
 
				+    Only rows that are still NULL are touched, and only from the 3MF already on
			
 
				+    disk -- nothing is invented and nothing already recorded is overwritten. An
			
 
				+    archive whose file is gone (a no-3MF fallback, or one whose 3MF has been
			
 
				+    cleaned up) is skipped and stays NULL, which is the honest answer.
			
 
				+
			
 
				+    Gated to run exactly once via a settings flag, like #2614's repair. The
			
 
				+    work itself is repeatable -- it only fills NULLs -- but the rows it cannot
			
 
				+    fill are exactly the ones it would re-open on every boot, and that set grows
			
 
				+    with print history.
			
 
				+    """
			
 
				+    from pathlib import Path
			
 
				+
			
 
				+    from sqlalchemy import text
			
 
				+
			
 
				+    from backend.app.utils.threemf_tools import extract_bed_temperature_from_3mf
			
 
				+
			
 
				+    flag = "_backfill_2989_bed_temperature_done"
			
 
				+
			
 
				+    async with conn.begin_nested():
			
 
				+        already = (
			
 
				+            await conn.execute(text('SELECT value FROM settings WHERE "key" = :k'), {"k": flag})
			
 
				+        ).scalar_one_or_none()
			
 
				+        if already is not None:
			
 
				+            # Presence, not truthiness. A flag row that somehow holds an empty
			
 
				+            # string would otherwise re-run and then fail the unique key on the
			
 
				+            # INSERT below -- which, at startup, is a boot loop.
			
 
				+            return
			
 
				+
			
 
				+        rows = (
			
 
				+            await conn.execute(
			
 
				+                text(
			
 
				+                    "SELECT id, file_path FROM print_archives "
			
 
				+                    "WHERE bed_temperature IS NULL "
			
 
				+                    "AND file_path IS NOT NULL AND file_path != ''"
			
 
				+                )
			
 
				+            )
			
 
				+        ).fetchall()
			
 
				+
			
 
				+        filled = 0
			
 
				+        for row in rows:
			
 
				+            # Per row, and broad, for the reason in the extractor's docstring:
			
 
				+            # nothing above this has a handler, so one unreadable archive must
			
 
				+            # not cost the user their boot. #2614's repair guards its rows the
			
 
				+            # same way.
			
 
				+            try:
			
 
				+                path = Path(row.file_path)
			
 
				+                if not path.is_absolute():
			
 
				+                    path = settings.base_dir / row.file_path
			
 
				+                if not path.exists():
			
 
				+                    continue
			
 
				+                temperature = extract_bed_temperature_from_3mf(path)
			
 
				+            except Exception as exc:
			
 
				+                logger.warning("[#2989] could not read %s for archive %s: %s", row.file_path, row.id, exc)
			
 
				+                continue
			
 
				+            if not temperature:
			
 
				+                continue
			
 
				+            await conn.execute(
			
 
				+                text("UPDATE print_archives SET bed_temperature = :t WHERE id = :id"),
			
 
				+                {"t": temperature, "id": row.id},
			
 
				+            )
			
 
				+            filled += 1
			
 
				+
			
 
				+        if filled:
			
 
				+            logger.info(
			
 
				+                "[#2989] Read the bed temperature from the 3MF for %d archive(s) that had none",
			
 
				+                filled,
			
 
				+            )
			
 
				+
			
 
				+        # Marked done even when nothing matched, so the rows it could not fill --
			
 
				+        # which are exactly the ones it would re-open every boot -- are not
			
 
				+        # rescanned forever. Same shape as #2614's one-shot.
			
 
				+        await conn.execute(
			
 
				+            text('INSERT INTO settings ("key", value) VALUES (:k, :v)'),
			
 
				+            {"k": flag, "v": "true"},
			
 
				+        )
			
 
				+
			
 
				+
			
 
				 async def _migrate_drop_library_print_name(conn) -> None:
			
 
				     """Strip the embedded 3MF Title (``print_name``) from library file metadata (#1489).
			
 
				 
			
@@ -1239,6 +1479,255 @@ async def _migrate_add_print_archive_cost_center(conn) -> None:
 
				     )
			
 
				 
			
 
				 
			
 
				+# Historical failure-reason labels, mapped to the canonical key that replaced
			
 
				+# them (issue #2974).
			
 
				+#
			
 
				+# Three writers used to put three different spellings of one cause into
			
 
				+# ``failure_reason``: the backend wrote English display labels, older versions
			
 
				+# of the archive editor wrote the *translated* label in whatever locale that
			
 
				+# user was running, and two stale-archive paths wrote English prose sentences.
			
 
				+# The Failure Analysis widget groups on the raw column, so one real cause could
			
 
				+# occupy several buckets -- measured on a live install before this landed: 91
			
 
				+# rows reading "User cancelled" beside 1 reading "userCancelled", which in an
			
 
				+# English UI rendered as the same words twice with different counts.
			
 
				+#
			
 
				+# This is deliberately a FROZEN SNAPSHOT rather than something derived from the
			
 
				+# locale files at run time. It maps values as they were written historically; if
			
 
				+# a translation is reworded tomorrow, the old string is still what sits in the
			
 
				+# database and still has to map. Regenerating it from ``en.ts`` and friends
			
 
				+# would silently stop recognising the very rows it exists to convert.
			
 
				+#
			
 
				+# Every label here resolves to exactly one key -- verified across all 14 locales
			
 
				+# with no collisions -- so the conversion is exact rather than a best guess. A
			
 
				+# value that is NOT in this map (free text from an older build, a translation
			
 
				+# since edited) is deliberately left alone: it already renders through the
			
 
				+# ``defaultValue`` fallback in both the editor and the Statistics breakdown, and
			
 
				+# guessing at it would be worse than leaving one honest string in its own bucket.
			
 
				+_LEGACY_FAILURE_REASON_LABELS: dict[str, str] = {
			
 
				+    "Adhesion failure": "adhesionFailure",
			
 
				+    "Agotamiento del filamento": "filamentRunout",
			
 
				+    "Alabeo": "warping",
			
 
				+    "Altro": "other",
			
 
				+    "Annullato dall'utente": "userCancelled",
			
 
				+    "Annulé par l'utilisateur": "userCancelled",
			
 
				+    "Aucune mise à jour d'état reçue": "noStatusUpdate",
			
 
				+    "Autre": "other",
			
 
				+    "Az ekstrüzyon": "underExtrusion",
			
 
				+    "Bico entupido": "cloggedNozzle",
			
 
				+    "Boquilla obstruida": "cloggedNozzle",
			
 
				+    "Buse bouchée": "cloggedNozzle",
			
 
				+    "Bükülme": "warping",
			
 
				+    "Cancelada por el usuario": "userCancelled",
			
 
				+    "Cancelado pelo usuário": "userCancelled",
			
 
				+    "Clogged nozzle": "cloggedNozzle",
			
 
				+    "Corte de corriente": "powerFailure",
			
 
				+    "Coupure courant": "powerFailure",
			
 
				+    "Deformazione": "warping",
			
 
				+    "Deslocamento de camada": "layerShift",
			
 
				+    "Desplazamiento de capa": "layerShift",
			
 
				+    "Diğer": "other",
			
 
				+    "Door gebruiker geannuleerd": "userCancelled",
			
 
				+    "Draadvorming": "stringing",
			
 
				+    "Durum güncellemesi alınmadı": "noStatusUpdate",
			
 
				+    "Décalage de couche": "layerShift",
			
 
				+    "Défaut d'adhésion": "adhesionFailure",
			
 
				+    "Empenamento": "warping",
			
 
				+    "Espagueti / Desprendido": "spaghettiDetached",
			
 
				+    "Fadenziehen": "stringing",
			
 
				+    "Falha de adesão": "adhesionFailure",
			
 
				+    "Falha de energia": "powerFailure",
			
 
				+    "Fallimento adesione": "adhesionFailure",
			
 
				+    "Fallo de adhesión": "adhesionFailure",
			
 
				+    "Filament aufgebraucht": "filamentRunout",
			
 
				+    "Filament bitti": "filamentRunout",
			
 
				+    "Filament fini": "filamentRunout",
			
 
				+    "Filament op": "filamentRunout",
			
 
				+    "Filament runout": "filamentRunout",
			
 
				+    "Filamento": "stringing",
			
 
				+    "Filamento esaurito": "filamentRunout",
			
 
				+    "Fim do filamento": "filamentRunout",
			
 
				+    "Fios": "stringing",
			
 
				+    "Geen statusupdate ontvangen": "noStatusUpdate",
			
 
				+    "Güç kesintisi": "powerFailure",
			
 
				+    "Haftungsfehler": "adhesionFailure",
			
 
				+    "Hechtingsprobleem": "adhesionFailure",
			
 
				+    "Hilos": "stringing",
			
 
				+    "Katman kayması": "layerShift",
			
 
				+    "Kein Statusupdate empfangen": "noStatusUpdate",
			
 
				+    "Kromtrekken": "warping",
			
 
				+    "Kullanıcı iptal etti": "userCancelled",
			
 
				+    "Laagverschuiving": "layerShift",
			
 
				+    "Layer shift": "layerShift",
			
 
				+    "Mancanza corrente": "powerFailure",
			
 
				+    "Nenhuma atualização de status recebida": "noStatusUpdate",
			
 
				+    "Nessun aggiornamento di stato ricevuto": "noStatusUpdate",
			
 
				+    "No se recibió actualización de estado": "noStatusUpdate",
			
 
				+    "No status update received": "noStatusUpdate",
			
 
				+    "Onderextrusie": "underExtrusion",
			
 
				+    "Other": "other",
			
 
				+    "Otro": "other",
			
 
				+    "Outro": "other",
			
 
				+    "Overig": "other",
			
 
				+    "Power failure": "powerFailure",
			
 
				+    "Schichtversatz": "layerShift",
			
 
				+    "Sonstiges": "other",
			
 
				+    "Sotto-estrusione": "underExtrusion",
			
 
				+    "Sous-extrusion": "underExtrusion",
			
 
				+    "Spagetti / Ayrılmış": "spaghettiDetached",
			
 
				+    "Spaghetti / Abgelöst": "spaghettiDetached",
			
 
				+    "Spaghetti / Destacado": "spaghettiDetached",
			
 
				+    "Spaghetti / Detached": "spaghettiDetached",
			
 
				+    "Spaghetti / Détaché": "spaghettiDetached",
			
 
				+    "Spaghetti / losgeraakt": "spaghettiDetached",
			
 
				+    "Spaghetti / staccato": "spaghettiDetached",
			
 
				+    "Spostamento layer": "layerShift",
			
 
				+    "Stale - print likely cancelled or failed without status update": "noStatusUpdate",
			
 
				+    "Stale - reconciled after reconnect, end time unknown": "noStatusUpdate",
			
 
				+    "Stringing": "stringing",
			
 
				+    "Stringing (Cheveux d'ange)": "stringing",
			
 
				+    "Stromausfall": "powerFailure",
			
 
				+    "Stroomuitval": "powerFailure",
			
 
				+    "Subextrusión": "underExtrusion",
			
 
				+    "Subextrusão": "underExtrusion",
			
 
				+    "Tıkalı nozul": "cloggedNozzle",
			
 
				+    "Ugello intasato": "cloggedNozzle",
			
 
				+    "Under-extrusion": "underExtrusion",
			
 
				+    "Unterextrusion": "underExtrusion",
			
 
				+    "User cancelled": "userCancelled",
			
 
				+    "Verformung": "warping",
			
 
				+    "Verstopfte Düse": "cloggedNozzle",
			
 
				+    "Verstopte nozzle": "cloggedNozzle",
			
 
				+    "Vom Benutzer abgebrochen": "userCancelled",
			
 
				+    "Warping": "warping",
			
 
				+    "Warping (Déformation)": "warping",
			
 
				+    "Yapışma başarısız": "adhesionFailure",
			
 
				+    "İplik oluşumu": "stringing",
			
 
				+    "Биття філаменту": "filamentRunout",
			
 
				+    "Викривлення": "warping",
			
 
				+    "Другое": "other",
			
 
				+    "Закончился филамент": "filamentRunout",
			
 
				+    "Засмічене сопло": "cloggedNozzle",
			
 
				+    "Засор сопла": "cloggedNozzle",
			
 
				+    "Збій живлення": "powerFailure",
			
 
				+    "Зсув шару": "layerShift",
			
 
				+    "Користувач скасовано": "userCancelled",
			
 
				+    "Коробление": "warping",
			
 
				+    "Нанизування": "stringing",
			
 
				+    "Недоэкструзия": "underExtrusion",
			
 
				+    "Обновление статуса не получено": "noStatusUpdate",
			
 
				+    "Оновлення статусу не отримано": "noStatusUpdate",
			
 
				+    "Отменено пользователем": "userCancelled",
			
 
				+    "Плохая адгезия к столу": "adhesionFailure",
			
 
				+    "Порушення адгезії": "adhesionFailure",
			
 
				+    "Підвидавлювання": "underExtrusion",
			
 
				+    "Сбой питания": "powerFailure",
			
 
				+    "Сдвиг слоёв": "layerShift",
			
 
				+    "Спагетти / отрыв детали": "spaghettiDetached",
			
 
				+    "Спагетті / Відр": "spaghettiDetached",
			
 
				+    "Стрингинг": "stringing",
			
 
				+    "інше": "other",
			
 
				+    "その他": "other",
			
 
				+    "ステータス更新を受信できませんでした": "noStatusUpdate",
			
 
				+    "スパゲッティ / 剥離": "spaghettiDetached",
			
 
				+    "ノズル詰まり": "cloggedNozzle",
			
 
				+    "フィラメント切れ": "filamentRunout",
			
 
				+    "ユーザーによるキャンセル": "userCancelled",
			
 
				+    "レイヤーシフト": "layerShift",
			
 
				+    "使用者取消": "userCancelled",
			
 
				+    "其他": "other",
			
 
				+    "反り": "warping",
			
 
				+    "喷嘴堵塞": "cloggedNozzle",
			
 
				+    "噴嘴堵塞": "cloggedNozzle",
			
 
				+    "定着不良": "adhesionFailure",
			
 
				+    "层偏移": "layerShift",
			
 
				+    "層偏移": "layerShift",
			
 
				+    "押出不足": "underExtrusion",
			
 
				+    "拉丝": "stringing",
			
 
				+    "拉丝 / 脱落": "spaghettiDetached",
			
 
				+    "拉絲": "stringing",
			
 
				+    "拉絲 / 脫落": "spaghettiDetached",
			
 
				+    "挤出不足": "underExtrusion",
			
 
				+    "擠出不足": "underExtrusion",
			
 
				+    "断电": "powerFailure",
			
 
				+    "斷電": "powerFailure",
			
 
				+    "未收到状态更新": "noStatusUpdate",
			
 
				+    "未收到狀態更新": "noStatusUpdate",
			
 
				+    "用户取消": "userCancelled",
			
 
				+    "糸引き": "stringing",
			
 
				+    "翘曲": "warping",
			
 
				+    "翹曲": "warping",
			
 
				+    "耗材用完": "filamentRunout",
			
 
				+    "附着力失败": "adhesionFailure",
			
 
				+    "附著力失敗": "adhesionFailure",
			
 
				+    "電源障害": "powerFailure",
			
 
				+    "기타": "other",
			
 
				+    "노즐 막힘": "cloggedNozzle",
			
 
				+    "레이어 시프트": "layerShift",
			
 
				+    "사용자 취소": "userCancelled",
			
 
				+    "상태 업데이트를 받지 못함": "noStatusUpdate",
			
 
				+    "스트링": "stringing",
			
 
				+    "스파게티 / 분리": "spaghettiDetached",
			
 
				+    "압출 부족": "underExtrusion",
			
 
				+    "전원 실패": "powerFailure",
			
 
				+    "접착 실패": "adhesionFailure",
			
 
				+    "필라멘트 소진": "filamentRunout",
			
 
				+    "휨": "warping",
			
 
				+}
			
 
				+
			
 
				+
			
 
				+async def _migrate_failure_reason_vocabulary(conn):
			
 
				+    """Fold historical failure-reason labels onto the canonical keys (#2974).
			
 
				+
			
 
				+    ``print_archives.failure_reason`` and ``print_log_entries.failure_reason``
			
 
				+    accumulated three spellings of the same cause -- see
			
 
				+    ``_LEGACY_FAILURE_REASON_LABELS`` for who wrote what. The PATCH route in
			
 
				+    ``api/routes/print_log.py`` has enforced the key vocabulary for a while and
			
 
				+    ``derive_failure_reason`` now produces it too, so this is the one-time pass
			
 
				+    that brings existing rows in line.
			
 
				+
			
 
				+    Deliberately NOT gated behind a settings flag, unlike the #2614 backfill.
			
 
				+    The statement is self-terminating -- it only matches values in the map, and
			
 
				+    a key is never a label, so a second run updates nothing -- which makes the
			
 
				+    flag pure overhead. It would also be actively wrong: a user who restores an
			
 
				+    older database, or upgrades through this version twice, would carry the flag
			
 
				+    with none of the conversion, and their legacy rows would never be touched
			
 
				+    again. Cheap and repeatable beats one-shot here.
			
 
				+    """
			
 
				+    from collections import defaultdict
			
 
				+
			
 
				+    from sqlalchemy import bindparam, text
			
 
				+
			
 
				+    # Invert the map before issuing anything: 168 labels collapse onto 12 keys,
			
 
				+    # so one UPDATE per key with an IN list is 24 statements rather than 336
			
 
				+    # single-value ones on every boot. Identity rows (an en.ts label that is
			
 
				+    # spelled the same as its own key) are dropped -- they would match and
			
 
				+    # rewrite themselves to the value they already hold.
			
 
				+    by_key: dict[str, list[str]] = defaultdict(list)
			
 
				+    for label, key in _LEGACY_FAILURE_REASON_LABELS.items():
			
 
				+        if label != key:
			
 
				+            by_key[key].append(label)
			
 
				+
			
 
				+    total = 0
			
 
				+    async with conn.begin_nested():
			
 
				+        # nosec B608 — the only interpolated fragment is `table`, which the loop
			
 
				+        # below draws from a literal tuple; no caller value reaches the string.
			
 
				+        # Both the key and the label list are bound parameters. A table name
			
 
				+        # cannot be expressed as one, which is why it is interpolated at all.
			
 
				+        for table in ("print_archives", "print_log_entries"):
			
 
				+            for key, labels in by_key.items():
			
 
				+                result = await conn.execute(
			
 
				+                    text(
			
 
				+                        f"UPDATE {table} SET failure_reason = :key "  # noqa: S608  # nosec B608
			
 
				+                        "WHERE failure_reason IN :labels"
			
 
				+                    ).bindparams(bindparam("key"), bindparam("labels", expanding=True)),
			
 
				+                    {"key": key, "labels": labels},
			
 
				+                )
			
 
				+                total += result.rowcount or 0
			
 
				+
			
 
				+    if total:
			
 
				+        logger.info("[#2974] converted %d failure_reason value(s) to the canonical vocabulary", total)
			
 
				+
			
 
				+
			
 
				 async def run_migrations(conn):
			
 
				     """Run all schema migrations and data backfills on startup.
			
 
				 
			
@@ -1258,6 +1747,11 @@ async def run_migrations(conn):
 
				     # them. Fresh installs remain idempotent because create_all() runs first.
			
 
				     await _migrate_create_finance_tables(conn)
			
 
				 
			
 
				+    # Data migration: one vocabulary for failure_reason (#2974). Runs early so
			
 
				+    # the Failure Analysis widget and the archive editor never observe a
			
 
				+    # half-converted column.
			
 
				+    await _migrate_failure_reason_vocabulary(conn)
			
 
				+
			
 
				     # Migration: Add parent_run_id column to pipeline_runs (#1425 PR C).
			
 
				     # Links a retry-failed run back to its parent so the dashboard can show
			
 
				     # "Retry of run #N" inline. Idempotent on both SQLite and Postgres.
			
@@ -1268,8 +1762,8 @@ async def run_migrations(conn):
 
				 
			
 
				     # Migration: Add source_archive_id column to pipeline_runs (#1425 PR B follow-up).
			
 
				     # Allows a pipeline run to source from an archive's source 3MF in addition
			
 
				-    # to a library file. Idempotent — _safe_execute swallows the "already exists"
			
 
				-    # case on both SQLite and Postgres.
			
 
				+    # to a library file. Idempotent — _safe_execute swallows an already-applied
			
 
				+    # statement on both SQLite and Postgres.
			
 
				     await _safe_execute(
			
 
				         conn,
			
 
				         "ALTER TABLE pipeline_runs ADD COLUMN source_archive_id INTEGER REFERENCES print_archives(id) ON DELETE SET NULL",
			
@@ -2030,7 +2524,7 @@ async def run_migrations(conn):
 
				     # timestamp; the type differs by dialect (SQLite DATETIME vs Postgres
			
 
				     # TIMESTAMP) so an existing-DB upgrade doesn't hit "type datetime does not
			
 
				     # exist" on Postgres. On a fresh DB create_all() already built the column, so
			
 
				-    # the ALTER is swallowed as "already exists".
			
 
				+    # the ALTER is swallowed as already applied.
			
 
				     #
			
 
				     # Placed AFTER the print_queue_new2 table-recreate above: that recreate
			
 
				     # (SQLite-only, and only on ancient DBs whose archive_id is still NOT NULL)
			
@@ -3224,17 +3718,17 @@ async def run_migrations(conn):
 
				     # SQLite does not support ALTER TABLE ADD CONSTRAINT — handled by __table_args__ at creation.
			
 
				     # Runs AFTER the backfill so Fall B rows don't fail constraint validation.
			
 
				     if not is_sqlite():
			
 
				+        add_constraint = (
			
 
				+            "ALTER TABLE oidc_providers ADD CONSTRAINT ck_auto_link_requires_verified_email_claim "
			
 
				+            "CHECK (auto_link_existing_accounts = FALSE OR email_claim != 'email' OR require_email_verified = TRUE)"
			
 
				+        )
			
 
				         try:
			
 
				             async with conn.begin_nested():
			
 
				-                await conn.execute(
			
 
				-                    text(
			
 
				-                        "ALTER TABLE oidc_providers ADD CONSTRAINT ck_auto_link_requires_verified_email_claim "
			
 
				-                        "CHECK (auto_link_existing_accounts = FALSE OR email_claim != 'email' OR require_email_verified = TRUE)"
			
 
				-                    )
			
 
				-                )
			
 
				+                await conn.execute(text(add_constraint))
			
 
				         except (OperationalError, ProgrammingError) as exc:
			
 
				-            msg = str(exc).lower()
			
 
				-            if "already exists" not in msg:
			
 
				+            # Classified by SQLSTATE, not by message text: a non-English server
			
 
				+            # reports the constraint as already present in its own language (#2949).
			
 
				+            if not _is_already_applied(exc, add_constraint):
			
 
				                 logger.error(
			
 
				                     "Security constraint migration FAILED — auto_link safety constraint may not be enforced: %s",
			
 
				                     exc,
			
@@ -3862,6 +4356,34 @@ async def run_migrations(conn):
 
				             conn, "ALTER TABLE notification_providers ADD COLUMN on_stock_break_alert BOOLEAN DEFAULT false"
			
 
				         )
			
 
				 
			
 
				+    # Backfill the two flags above. The DEFAULT on those ALTERs only reaches
			
 
				+    # existing rows when the ALTER is the statement that adds the column -- and
			
 
				+    # on an install whose notification_providers table was (re)created from
			
 
				+    # Base.metadata, create_all() had already added them by the time migrations
			
 
				+    # ran, so _safe_execute swallowed the ALTER as a duplicate column and every
			
 
				+    # pre-existing row kept NULL. Harmless while nothing read the flags; a 500
			
 
				+    # on the whole provider list once #2827 declared them on the response
			
 
				+    # schema, because pydantic will not accept None for a bool.
			
 
				+    #
			
 
				+    # false matches both the intent of the DEFAULT above and the behaviour the
			
 
				+    # rows already have: _get_providers_for_event filters on `.is_(True)`, so a
			
 
				+    # NULL flag never sent anything. Idempotent -- the WHERE matches nothing on
			
 
				+    # the second run.
			
 
				+    async with conn.begin_nested():
			
 
				+        stock_backfill = await conn.execute(
			
 
				+            text(
			
 
				+                "UPDATE notification_providers SET on_stock_reorder_alert = :off WHERE on_stock_reorder_alert IS NULL"
			
 
				+            ),
			
 
				+            {"off": False},
			
 
				+        )
			
 
				+        stock_backfill_break = await conn.execute(
			
 
				+            text("UPDATE notification_providers SET on_stock_break_alert = :off WHERE on_stock_break_alert IS NULL"),
			
 
				+            {"off": False},
			
 
				+        )
			
 
				+    repaired = (stock_backfill.rowcount or 0) + (stock_backfill_break.rowcount or 0)
			
 
				+    if repaired:
			
 
				+        logger.info("Backfilled %s NULL inventory stock alert flag(s) on notification_providers", repaired)
			
 
				+
			
 
				     # Migration: Heal orphan auth-related rows left behind by user-delete
			
 
				     # on SQLite. user_oidc_links, user_totp, user_otp_codes (introduced in
			
 
				     # PR #933) and long_lived_tokens (PR #1108) all declare ON DELETE
			
@@ -4280,6 +4802,16 @@ async def run_migrations(conn):
 
				     # #2603 archive plate_id backfill above so print_archives.plate_id is populated.
			
 
				     await _migrate_scope_run_filament_to_plate(conn)
			
 
				 
			
 
				+    # Backfill: archives written before #2989 have no bed temperature, because
			
 
				+    # the extractor looked for a key BambuStudio never writes. Re-reads the 3MF
			
 
				+    # already on disk. One-shot; see the function for why it is gated.
			
 
				+    await _backfill_archive_bed_temperature(conn)
			
 
				+
			
 
				+    # Backfill: library rows typed from the filename alone kept a sliced 3MF
			
 
				+    # named `Foo.3mf` filed as a source-only project (#2993). Re-reads the zip
			
 
				+    # already on disk. One-shot, internal rows only; see the function.
			
 
				+    await _reclassify_sliced_3mf_library_files(conn)
			
 
				+
			
 
				     # Migration: Add controls_printer_power to smart_plugs (#2629). Marks
			
 
				     # whether a plug actually feeds the printer's own power — only then may an
			
 
				     # auto-off mark the printer offline. Defaults to true so existing plugs
			
@@ -4301,7 +4833,7 @@ async def run_migrations(conn):
 
				     # ordering was arbitrary. Nullable; the timestamp type differs by dialect
			
 
				     # (SQLite DATETIME vs Postgres TIMESTAMP) so an existing-DB upgrade doesn't hit
			
 
				     # "type datetime does not exist" on Postgres. On a fresh DB create_all() already
			
 
				-    # built the column, so the ALTER is swallowed as "already exists".
			
 
				+    # built the column, so the ALTER is swallowed as already applied.
			
 
				     if is_sqlite():
			
 
				         await _safe_execute(conn, "ALTER TABLE library_files ADD COLUMN fs_modified_at DATETIME")
			
 
				         await _safe_execute(conn, "ALTER TABLE library_folders ADD COLUMN fs_modified_at DATETIME")
			
@@ -4392,6 +4924,278 @@ async def run_migrations(conn):
 
				         conn, "ALTER TABLE notification_providers ADD COLUMN on_ams_drying_suspended BOOLEAN DEFAULT TRUE"
			
 
				     )
			
 
				 
			
 
				+    # Migration: storage location sensor alerts (#2824), own column rather than
			
 
				+    # reusing on_ha_sensor_alert. That column can be scoped to one printer
			
 
				+    # (printer_id), and a location alert has no printer to scope by — sharing
			
 
				+    # the column meant a provider narrowed to one printer's sensors silently
			
 
				+    # also received every drybox alert, with no toggle to separate the two.
			
 
				+    await _safe_execute(
			
 
				+        conn, "ALTER TABLE notification_providers ADD COLUMN on_location_ha_sensor_alert BOOLEAN DEFAULT FALSE"
			
 
				+    )
			
 
				+
			
 
				+    # Migration: rename the ha_sensor_alert template (#2824). "Home Assistant
			
 
				+    # Sensor Alert" was fine as a name while it was the only such template;
			
 
				+    # next to the new "Storage Location Sensor Alert" it no longer says which
			
 
				+    # one is the printer's. See _migrate_rename_user_print_template_names for
			
 
				+    # why this is a plain UPDATE guarded on the old name rather than a
			
 
				+    # DEFAULT_TEMPLATES re-seed.
			
 
				+    await _migrate_rename_ha_sensor_alert_template(conn)
			
 
				+
			
 
				+    # Migration: back the one-binding-per-(location, entity) rule with a unique
			
 
				+    # index (#2824). The API's duplicate check is read-then-insert, so two
			
 
				+    # concurrent creates could both pass it; the index turns the loser into an
			
 
				+    # IntegrityError the route maps back to the same 400. create_all() adds it
			
 
				+    # on fresh installs only — this covers databases whose table predates it.
			
 
				+    await _migrate_location_ha_sensor_unique_binding(conn)
			
 
				+
			
 
				+    # Migration: repair the tare of spools the RFID auto-add gave the wrong
			
 
				+    # Bambu spool row (#2909). Runs last so the spool catalogue it reads is
			
 
				+    # whatever this database actually holds.
			
 
				+    await _migrate_repair_rfid_core_weight(conn)
			
 
				+
			
 
				+    # Migration: drop the AMS slot markers an older Bambuddy wrote into
			
 
				+    # Spoolman and the location sync then imported as storage locations.
			
 
				+    await _migrate_drop_ams_slot_locations(conn)
			
 
				+
			
 
				+
			
 
				+async def _migrate_rename_ha_sensor_alert_template(conn) -> None:
			
 
				+    """Rename the ha_sensor_alert template to "Printer Sensor Alert" (#2824).
			
 
				+
			
 
				+    Renames only if ``name`` is still the old default — an admin who renamed
			
 
				+    the template themselves keeps their custom name.
			
 
				+    """
			
 
				+    from sqlalchemy import text
			
 
				+
			
 
				+    await conn.execute(
			
 
				+        text("UPDATE notification_templates SET name = :new WHERE event_type = :et AND name = :old"),
			
 
				+        {"new": "Printer Sensor Alert", "et": "ha_sensor_alert", "old": "Home Assistant Sensor Alert"},
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+async def _migrate_location_ha_sensor_unique_binding(conn) -> None:
			
 
				+    """Unique index on location_ha_sensors (location_id, entity_id) (#2824).
			
 
				+
			
 
				+    Same name and shape as the Index in the model, so fresh installs (which
			
 
				+    get it from create_all) and upgraded ones end up identical.
			
 
				+
			
 
				+    Rows that already violate it — duplicates slipped in through the pre-index
			
 
				+    race — are collapsed to the oldest row first, because CREATE UNIQUE INDEX
			
 
				+    refuses to build over duplicates and _safe_execute would re-raise that,
			
 
				+    aborting startup. The oldest row wins: it is the one the card and the
			
 
				+    poller cache were already keyed on.
			
 
				+    """
			
 
				+    from sqlalchemy import text
			
 
				+
			
 
				+    async with conn.begin_nested():
			
 
				+        await conn.execute(
			
 
				+            text(
			
 
				+                "DELETE FROM location_ha_sensors WHERE id NOT IN ("
			
 
				+                "SELECT MIN(id) FROM location_ha_sensors GROUP BY location_id, entity_id)"
			
 
				+            )
			
 
				+        )
			
 
				+    await _safe_execute(
			
 
				+        conn,
			
 
				+        "CREATE UNIQUE INDEX IF NOT EXISTS uq_location_ha_sensors_location_entity "
			
 
				+        "ON location_ha_sensors (location_id, entity_id)",
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+async def _migrate_drop_ams_slot_locations(conn) -> None:
			
 
				+    """Remove imported AMS slot markers from the storage-location catalogue.
			
 
				+
			
 
				+    Bambuddy used to record which slot a spool was loaded into by writing
			
 
				+    "<printer> - AMS A1" into Spoolman's ``location`` field. That writer went
			
 
				+    away when Storage Location became something the user picks (#1114), but the
			
 
				+    strings stayed on people's Spoolman spools, and
			
 
				+    ``sync_locations_from_spoolman`` imported every distinct one -- so a printer
			
 
				+    slot turned up in the Storage Location dropdown as somewhere to put a spool
			
 
				+    away. Worse, they could not be cleared by hand: the delete route refuses a
			
 
				+    location that has spools, and in Spoolman mode it counts them by matching
			
 
				+    that same string, so every marker still on a loaded spool answered 409.
			
 
				+
			
 
				+    The import now skips them (``is_ams_slot_location``); this clears the ones
			
 
				+    already in the catalogue. A row is only deleted when no spool in this
			
 
				+    database points at it -- neither by ``location_id`` nor by a legacy
			
 
				+    free-text ``storage_location`` -- so an internal-mode user who has
			
 
				+    deliberately filed spools under such a name keeps it, dropdown entry and
			
 
				+    all.
			
 
				+
			
 
				+    Spools in Spoolman are not consulted and not touched: their ``location``
			
 
				+    strings are the user's data on the user's server, and one that still reads
			
 
				+    "H2D-1 - AMS A1" in the inventory list is telling the truth about what
			
 
				+    Spoolman holds. It simply stops being offered as a destination, which is
			
 
				+    the whole point -- those are exactly the markers this cleans up.
			
 
				+    """
			
 
				+    from sqlalchemy import text
			
 
				+
			
 
				+    from backend.app.services.location_service import is_ams_slot_location, location_name_key
			
 
				+
			
 
				+    flag = "_cleanup_ams_slot_locations_done"
			
 
				+
			
 
				+    async with conn.begin_nested():
			
 
				+        already = (
			
 
				+            await conn.execute(text('SELECT value FROM settings WHERE "key" = :k'), {"k": flag})
			
 
				+        ).scalar_one_or_none()
			
 
				+        if already:
			
 
				+            return
			
 
				+
			
 
				+        rows = (await conn.execute(text("SELECT id, name FROM locations"))).fetchall()
			
 
				+        removed = []
			
 
				+        for row in rows:
			
 
				+            if not is_ams_slot_location(row.name):
			
 
				+                continue
			
 
				+            in_use = (
			
 
				+                await conn.execute(
			
 
				+                    text(
			
 
				+                        "SELECT COUNT(*) FROM spool WHERE location_id = :id "
			
 
				+                        "OR LOWER(TRIM(COALESCE(storage_location, ''))) = :key"
			
 
				+                    ),
			
 
				+                    {"id": row.id, "key": location_name_key(row.name)},
			
 
				+                )
			
 
				+            ).scalar_one()
			
 
				+            if in_use:
			
 
				+                continue
			
 
				+            await conn.execute(text("DELETE FROM locations WHERE id = :id"), {"id": row.id})
			
 
				+            removed.append(row.name)
			
 
				+
			
 
				+        if removed:
			
 
				+            logger.info(
			
 
				+                "Removed %d AMS slot marker(s) from the storage-location catalogue: %s",
			
 
				+                len(removed),
			
 
				+                ", ".join(sorted(removed)),
			
 
				+            )
			
 
				+
			
 
				+        await conn.execute(
			
 
				+            text('INSERT INTO settings ("key", value) VALUES (:k, :v)'),
			
 
				+            {"k": flag, "v": "true"},
			
 
				+        )
			
 
				+
			
 
				+
			
 
				+async def _migrate_repair_rfid_core_weight(conn) -> None:
			
 
				+    """Correct the tare of RFID-added spools that took the wrong catalogue row (#2909).
			
 
				+
			
 
				+    A Bambu roll arrives on the 250 g Low Temp spool, but the lookup that gave
			
 
				+    an auto-added spool its ``core_weight`` asked for the first row whose name
			
 
				+    starts "Bambu Lab" and took whatever came back. There are three, and which
			
 
				+    one is first is up to the database: SQLite returns insertion order in
			
 
				+    practice, Postgres promises nothing once the table has seen an update. So
			
 
				+    the same roll could be recorded with a 216 g High Temp tare on one install
			
 
				+    and correctly on another, and the reporting instance here got 216.
			
 
				+
			
 
				+    The tare is not cosmetic. A spool weighed on SpoolBuddy has its remaining
			
 
				+    filament worked out as ``scale reading - core_weight``, so a 34 g low tare
			
 
				+    credits the roll with 34 g of filament that is not there and writes a
			
 
				+    ``weight_used`` 34 g short. That error is a constant: every later print
			
 
				+    adds to ``weight_used`` on top of it, so adding the difference back is an
			
 
				+    exact repair however much has been printed since. Only rows that have
			
 
				+    actually been weighed carry it -- a spool that was never on the scale has
			
 
				+    a ``weight_used`` derived from the AMS remaining percentage, which the tare
			
 
				+    never touched.
			
 
				+
			
 
				+    Which rows: ``data_origin = 'rfid_auto'`` narrows it to spools this code
			
 
				+    path created, and a ``core_weight`` matching one of the *other* Bambu
			
 
				+    catalogue rows is the signature of the broken lookup. Reading the weights
			
 
				+    out of the catalogue rather than hardcoding 216 and 253 keeps it correct on
			
 
				+    an install whose catalogue has been edited.
			
 
				+
			
 
				+    One case cannot be told apart and is stated rather than hidden: a user who
			
 
				+    moved an RFID roll onto a genuine High Temp spool and set its tare to 216
			
 
				+    by hand looks identical to a row the lookup got wrong, and is normalised
			
 
				+    with them. Keying on ``core_weight_catalog_id IS NULL`` instead would not
			
 
				+    have rescued them -- the spool form's weight picker auto-selects the only
			
 
				+    catalogue row matching the weight and writes its id on the next save, so
			
 
				+    that column says only whether the form was ever opened.
			
 
				+
			
 
				+    Gated to run exactly once via a settings flag, so a user who deliberately
			
 
				+    sets one of these tares afterwards keeps it.
			
 
				+    """
			
 
				+    from sqlalchemy import bindparam, text
			
 
				+
			
 
				+    # The same two values the creating path uses, imported rather than repeated:
			
 
				+    # a repair that looked for a different row than the code writes would leave
			
 
				+    # the tare it was built to correct in place. Imported inside the function to
			
 
				+    # keep this module free of a service-layer dependency at import time.
			
 
				+    from backend.app.services.spool_tag_matcher import (
			
 
				+        BAMBU_PLASTIC_SPOOL_CATALOG_NAME,
			
 
				+        BAMBU_PLASTIC_SPOOL_CORE_WEIGHT,
			
 
				+    )
			
 
				+
			
 
				+    flag = "_backfill_2909_rfid_core_weight_done"
			
 
				+
			
 
				+    async with conn.begin_nested():
			
 
				+        already = (
			
 
				+            await conn.execute(text('SELECT value FROM settings WHERE "key" = :k'), {"k": flag})
			
 
				+        ).scalar_one_or_none()
			
 
				+        if already:
			
 
				+            return
			
 
				+
			
 
				+        # The row that names the spool an RFID roll actually arrives on. Its
			
 
				+        # absence is not an error -- a catalogue the user has pruned still gets
			
 
				+        # the documented default.
			
 
				+        correct = (
			
 
				+            await conn.execute(
			
 
				+                text("SELECT id, weight FROM spool_catalog WHERE UPPER(name) = :name ORDER BY id LIMIT 1"),
			
 
				+                {"name": BAMBU_PLASTIC_SPOOL_CATALOG_NAME.upper()},
			
 
				+            )
			
 
				+        ).fetchone()
			
 
				+        correct_id = correct[0] if correct else None
			
 
				+        correct_weight = correct[1] if correct else BAMBU_PLASTIC_SPOOL_CORE_WEIGHT
			
 
				+
			
 
				+        bambu_weights = {
			
 
				+            row[0]
			
 
				+            for row in (
			
 
				+                await conn.execute(
			
 
				+                    text("SELECT weight FROM spool_catalog WHERE UPPER(name) LIKE :prefix"),
			
 
				+                    {"prefix": "BAMBU LAB%"},
			
 
				+                )
			
 
				+            ).fetchall()
			
 
				+        }
			
 
				+        wrong_weights = sorted(bambu_weights - {correct_weight})
			
 
				+
			
 
				+        repaired = 0
			
 
				+        reweighed = 0
			
 
				+        if wrong_weights:
			
 
				+            rows = (
			
 
				+                await conn.execute(
			
 
				+                    text(
			
 
				+                        "SELECT id, core_weight, label_weight, weight_used, last_weighed_at FROM spool "
			
 
				+                        "WHERE data_origin = 'rfid_auto' AND core_weight IN :wrong"
			
 
				+                    ).bindparams(bindparam("wrong", expanding=True)),
			
 
				+                    {"wrong": wrong_weights},
			
 
				+                )
			
 
				+            ).fetchall()
			
 
				+
			
 
				+            for row in rows:
			
 
				+                delta = correct_weight - row.core_weight
			
 
				+                weight_used = row.weight_used or 0.0
			
 
				+                if row.last_weighed_at is not None:
			
 
				+                    weight_used = min(max(0.0, weight_used + delta), float(row.label_weight or 0))
			
 
				+                    reweighed += 1
			
 
				+                await conn.execute(
			
 
				+                    text(
			
 
				+                        "UPDATE spool SET core_weight = :cw, core_weight_catalog_id = :cid, "
			
 
				+                        "weight_used = :wu WHERE id = :id"
			
 
				+                    ),
			
 
				+                    {"cw": correct_weight, "cid": correct_id, "wu": weight_used, "id": row.id},
			
 
				+                )
			
 
				+                repaired += 1
			
 
				+
			
 
				+        if repaired:
			
 
				+            logger.info(
			
 
				+                "[#2909] Corrected the spool tare on %d RFID-added spool(s) to %d g; "
			
 
				+                "%d of them had been weighed and had their used weight adjusted with it",
			
 
				+                repaired,
			
 
				+                correct_weight,
			
 
				+                reweighed,
			
 
				+            )
			
 
				+
			
 
				+        # Marked done even when nothing matched, so the one-shot never reopens
			
 
				+        # a tare the user has since set for themselves.
			
 
				+        await conn.execute(
			
 
				+            text('INSERT INTO settings ("key", value) VALUES (:k, :v)'),
			
 
				+            {"k": flag, "v": "true"},
			
 
				+        )
			
 
				+
			
 
				 
			
 
				 async def _migrate_backfill_variant_groups(conn) -> None:
			
 
				     """Build variant groups from the slice provenance already on disk (#671 / #2570).
			
--- a/backend/app/main.py
+++ b/backend/app/main.py
--- a/backend/app/models/__init__.py
+++ b/backend/app/models/__init__.py
@@ -11,6 +11,7 @@ from backend.app.models.kprofile_note import KProfileNote
 
				 from backend.app.models.library import FileVariantGroup, LibraryFile, LibraryFolder
			
 
				 from backend.app.models.local_preset import LocalPreset
			
 
				 from backend.app.models.location import Location
			
 
				+from backend.app.models.location_ha_sensor import LocationHASensor
			
 
				 from backend.app.models.long_lived_token import LongLivedToken
			
 
				 from backend.app.models.maintenance import MaintenanceHistory, MaintenanceType, PrinterMaintenance
			
 
				 from backend.app.models.notification import NotificationLog
			
@@ -24,6 +25,7 @@ from backend.app.models.printer import Printer
 
				 from backend.app.models.printer_ha_sensor import PrinterHASensor
			
 
				 from backend.app.models.printer_sensor_history import PrinterSensorHistory
			
 
				 from backend.app.models.project import Project
			
 
				+from backend.app.models.scheduled_drying import ScheduledDrying
			
 
				 from backend.app.models.settings import Settings
			
 
				 from backend.app.models.slicer_pipeline import SlicerPipeline
			
 
				 from backend.app.models.smart_plug import SmartPlug
			
@@ -32,6 +34,7 @@ from backend.app.models.sponsor_toast_state import SponsorToastState
 
				 from backend.app.models.spool import Spool
			
 
				 from backend.app.models.spool_assignment import SpoolAssignment
			
 
				 from backend.app.models.spool_catalog import SpoolCatalogEntry
			
 
				+from backend.app.models.spool_filament_preset import SpoolFilamentPreset, SpoolmanFilamentPreset
			
 
				 from backend.app.models.spool_k_profile import SpoolKProfile
			
 
				 from backend.app.models.spool_usage_history import SpoolUsageHistory
			
 
				 from backend.app.models.spoolbuddy_device import SpoolBuddyDevice
			
@@ -58,6 +61,7 @@ __all__ = [
 
				     "AMSSensorHistory",
			
 
				     "PrinterSensorHistory",
			
 
				     "PrinterHASensor",
			
 
				+    "ScheduledDrying",
			
 
				     "AmsLabel",
			
 
				     "PendingUpload",
			
 
				     "PrintBatch",
			
@@ -79,7 +83,9 @@ __all__ = [
 
				     "PipelineRun",
			
 
				     "SlicerPipeline",
			
 
				     "Spool",
			
 
				+    "SpoolFilamentPreset",
			
 
				     "SpoolKProfile",
			
 
				+    "SpoolmanFilamentPreset",
			
 
				     "SpoolAssignment",
			
 
				     "SpoolCatalogEntry",
			
 
				     "SpoolUsageHistory",
			
--- a/backend/app/models/location.py
+++ b/backend/app/models/location.py
@@ -7,6 +7,7 @@ from sqlalchemy.orm import Mapped, mapped_column, relationship
 
				 from backend.app.core.database import Base
			
 
				 
			
 
				 if TYPE_CHECKING:
			
 
				+    from backend.app.models.location_ha_sensor import LocationHASensor
			
 
				     from backend.app.models.spool import Spool
			
 
				 
			
 
				 
			
@@ -25,3 +26,4 @@ class Location(Base):
 
				     updated_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.now(), onupdate=func.now())
			
 
				 
			
 
				     spools: Mapped[list["Spool"]] = relationship(back_populates="location")
			
 
				+    ha_sensors: Mapped[list["LocationHASensor"]] = relationship(back_populates="location", cascade="all, delete-orphan")
			
--- a/backend/app/models/location_ha_sensor.py
+++ b/backend/app/models/location_ha_sensor.py
@@ -0,0 +1,76 @@
 
				+from datetime import datetime
			
 
				+
			
 
				+from sqlalchemy import Boolean, DateTime, Float, ForeignKey, Index, Integer, String, func
			
 
				+from sqlalchemy.orm import Mapped, mapped_column, relationship
			
 
				+
			
 
				+from backend.app.core.database import Base
			
 
				+
			
 
				+# Width of the last_state column. The poller truncates what it persists to
			
 
				+# this, because a numeric entity can start reporting free text (an enum, an
			
 
				+# error string) longer than the column — SQLite stores it anyway, but
			
 
				+# PostgreSQL rejects the row and takes the whole poll batch's commit with it.
			
 
				+LAST_STATE_MAX_LENGTH = 64
			
 
				+
			
 
				+
			
 
				+class LocationHASensor(Base):
			
 
				+    """A read-only Home Assistant entity bound to a storage location (#2824).
			
 
				+
			
 
				+    Mirrors ``PrinterHASensor`` for dryboxes, bins and shelves instead of
			
 
				+    printers — same read-only binding, alert rule and notification, but no
			
 
				+    print-blocking: holding a print queue doesn't mean anything for a
			
 
				+    storage bin.
			
 
				+    """
			
 
				+
			
 
				+    __tablename__ = "location_ha_sensors"
			
 
				+    # The API rejects a duplicate (location, entity) binding, but that check is
			
 
				+    # read-then-insert — two concurrent creates can both pass it. This index is
			
 
				+    # the backstop that turns the loser into an IntegrityError instead of a
			
 
				+    # second row silently shadowing the first. create_all() only covers fresh
			
 
				+    # installs; upgraded databases get it from
			
 
				+    # _migrate_location_ha_sensor_unique_binding in core/database.py, which
			
 
				+    # must create the same index under the same name.
			
 
				+    __table_args__ = (Index("uq_location_ha_sensors_location_entity", "location_id", "entity_id", unique=True),)
			
 
				+
			
 
				+    id: Mapped[int] = mapped_column(primary_key=True)
			
 
				+    location_id: Mapped[int] = mapped_column(ForeignKey("locations.id", ondelete="CASCADE"), index=True)
			
 
				+
			
 
				+    name: Mapped[str] = mapped_column(String(100))
			
 
				+    entity_id: Mapped[str] = mapped_column(String(255))
			
 
				+
			
 
				+    # "binary" for binary_sensor.*, "numeric" for sensor.*. Decides how the
			
 
				+    # state is rendered and which alert fields apply.
			
 
				+    kind: Mapped[str] = mapped_column(String(16), default="binary")
			
 
				+
			
 
				+    # HA's own device_class, snapshotted when the entity is bound. Drives the
			
 
				+    # category a sensor is treated as (temperature/humidity/battery) and the
			
 
				+    # unit shown next to the value.
			
 
				+    device_class: Mapped[str | None] = mapped_column(String(32), nullable=True)
			
 
				+    # Numeric only: "°C", "%", ... shown next to the value.
			
 
				+    unit: Mapped[str | None] = mapped_column(String(16), nullable=True)
			
 
				+
			
 
				+    # What counts as needing attention. One notion, two consumers: the
			
 
				+    # colorized value on the card/table and the notification. Binary sensors
			
 
				+    # use alert_state ("on"/"off"/None), numeric ones the thresholds. All
			
 
				+    # None means "just show the value".
			
 
				+    alert_state: Mapped[str | None] = mapped_column(String(8), nullable=True)
			
 
				+    alert_above: Mapped[float | None] = mapped_column(Float, nullable=True)
			
 
				+    alert_below: Mapped[float | None] = mapped_column(Float, nullable=True)
			
 
				+
			
 
				+    notify_on_alert: Mapped[bool] = mapped_column(Boolean, default=False, server_default="0")
			
 
				+
			
 
				+    show_on_card: Mapped[bool] = mapped_column(Boolean, default=True, server_default="1")
			
 
				+    sort_order: Mapped[int] = mapped_column(Integer, default=0, server_default="0")
			
 
				+
			
 
				+    # Last poll result. Persisted so a restart doesn't blank the card until the
			
 
				+    # first poll lands, and so notifications only fire on a real transition.
			
 
				+    last_state: Mapped[str | None] = mapped_column(String(LAST_STATE_MAX_LENGTH), nullable=True)
			
 
				+    last_changed: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
			
 
				+    last_checked: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
			
 
				+
			
 
				+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.now())
			
 
				+    updated_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.now(), onupdate=func.now())
			
 
				+
			
 
				+    location: Mapped["Location"] = relationship(back_populates="ha_sensors")
			
 
				+
			
 
				+
			
 
				+from backend.app.models.location import Location  # noqa: E402
			
--- a/backend/app/models/notification.py
+++ b/backend/app/models/notification.py
@@ -89,6 +89,13 @@ class NotificationProvider(Base):
 
				     # Event triggers - Home Assistant sensors bound to a printer (#1148)
			
 
				     on_ha_sensor_alert = Column(Boolean, default=False)  # Bound HA sensor entered its alert state
			
 
				 
			
 
				+    # Event triggers - Home Assistant sensors bound to a storage location (#2824)
			
 
				+    # Its own column rather than reusing on_ha_sensor_alert above: that one can
			
 
				+    # be scoped to a single printer, and a location alert has no printer to
			
 
				+    # scope by, so sharing it would leak drybox alerts to a provider narrowed
			
 
				+    # to one printer's sensors.
			
 
				+    on_location_ha_sensor_alert = Column(Boolean, default=False)
			
 
				+
			
 
				     # Event triggers - Build plate detection
			
 
				     on_plate_not_empty = Column(Boolean, default=True)  # Objects detected on plate before print
			
 
				     # Off by default: fires after every print, alongside the print-complete alert (#2525)
			
--- a/backend/app/models/notification_template.py
+++ b/backend/app/models/notification_template.py
@@ -139,10 +139,16 @@ DEFAULT_TEMPLATES = [
 
				     },
			
 
				     {
			
 
				         "event_type": "ha_sensor_alert",
			
 
				-        "name": "Home Assistant Sensor Alert",
			
 
				+        "name": "Printer Sensor Alert",
			
 
				         "title_template": "Sensor Alert",
			
 
				         "body_template": "{printer}: {sensor} is {state}",
			
 
				     },
			
 
				+    {
			
 
				+        "event_type": "location_ha_sensor_alert",
			
 
				+        "name": "Storage Location Sensor Alert",
			
 
				+        "title_template": "Sensor Alert",
			
 
				+        "body_template": "{location}: {sensor} is {state}",
			
 
				+    },
			
 
				     {
			
 
				         "event_type": "first_layer_complete",
			
 
				         "name": "First Layer Complete",
			
--- a/backend/app/models/printer_ha_sensor.py
+++ b/backend/app/models/printer_ha_sensor.py
@@ -5,6 +5,13 @@ from sqlalchemy.orm import Mapped, mapped_column, relationship
 
				 
			
 
				 from backend.app.core.database import Base
			
 
				 
			
 
				+# Width of the last_state column. The poller truncates what it persists to
			
 
				+# this, because a numeric entity can start reporting free text (an enum, an
			
 
				+# error string) longer than the column -- SQLite stores it anyway, but
			
 
				+# PostgreSQL rejects the row and takes the whole poll batch's commit with it.
			
 
				+# Its sibling in models/location_ha_sensor.py says the same for that table.
			
 
				+LAST_STATE_MAX_LENGTH = 64
			
 
				+
			
 
				 
			
 
				 class PrinterHASensor(Base):
			
 
				     """A read-only Home Assistant entity bound to a printer (#1148, #448).
			
@@ -59,7 +66,7 @@ class PrinterHASensor(Base):
 
				 
			
 
				     # Last poll result. Persisted so a restart doesn't blank the card until the
			
 
				     # first poll lands, and so notifications only fire on a real transition.
			
 
				-    last_state: Mapped[str | None] = mapped_column(String(64), nullable=True)
			
 
				+    last_state: Mapped[str | None] = mapped_column(String(LAST_STATE_MAX_LENGTH), nullable=True)
			
 
				     last_changed: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
			
 
				     last_checked: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
			
 
				 
			
--- a/backend/app/models/scheduled_drying.py
+++ b/backend/app/models/scheduled_drying.py
@@ -0,0 +1,47 @@
 
				+from datetime import datetime
			
 
				+
			
 
				+from sqlalchemy import Boolean, DateTime, ForeignKey, Integer, String, Text, func
			
 
				+from sqlalchemy.orm import Mapped, mapped_column, relationship
			
 
				+
			
 
				+from backend.app.core.database import Base
			
 
				+
			
 
				+
			
 
				+class ScheduledDrying(Base):
			
 
				+    """A manual AMS drying run scheduled to start later (#2638).
			
 
				+
			
 
				+    Dispatched by PrintScheduler._check_scheduled_dryings() when start_after
			
 
				+    has passed and the printer is idle. Parameters mirror the immediate
			
 
				+    POST /printers/{id}/drying/start endpoint.
			
 
				+    """
			
 
				+
			
 
				+    __tablename__ = "scheduled_dryings"
			
 
				+
			
 
				+    id: Mapped[int] = mapped_column(primary_key=True)
			
 
				+    printer_id: Mapped[int] = mapped_column(ForeignKey("printers.id", ondelete="CASCADE"))
			
 
				+    ams_id: Mapped[int] = mapped_column(Integer, default=0)
			
 
				+
			
 
				+    temp: Mapped[int] = mapped_column(Integer)
			
 
				+    duration_hours: Mapped[int] = mapped_column(Integer)
			
 
				+    filament: Mapped[str] = mapped_column(String(50), default="")
			
 
				+    rotate_tray: Mapped[bool] = mapped_column(Boolean, default=False)
			
 
				+
			
 
				+    # Earliest start instant, naive UTC (same convention as
			
 
				+    # print_queue.scheduled_time). None = start as soon as the printer is idle.
			
 
				+    start_after: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
			
 
				+
			
 
				+    # pending / running / completed / cancelled / failed
			
 
				+    status: Mapped[str] = mapped_column(String(20), default="pending")
			
 
				+    waiting_reason: Mapped[str | None] = mapped_column(Text, nullable=True)
			
 
				+    error_message: Mapped[str | None] = mapped_column(Text, nullable=True)
			
 
				+
			
 
				+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.now())
			
 
				+    started_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
			
 
				+    completed_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
			
 
				+    created_by_id: Mapped[int | None] = mapped_column(ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
			
 
				+
			
 
				+    printer: Mapped["Printer"] = relationship()
			
 
				+    created_by: Mapped["User | None"] = relationship()
			
 
				+
			
 
				+
			
 
				+from backend.app.models.printer import Printer  # noqa: E402
			
 
				+from backend.app.models.user import User  # noqa: E402
			
--- a/backend/app/models/spool.py
+++ b/backend/app/models/spool.py
@@ -74,10 +74,18 @@ class Spool(Base):
 
				     updated_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.now(), onupdate=func.now())
			
 
				 
			
 
				     k_profiles: Mapped[list["SpoolKProfile"]] = relationship(back_populates="spool", cascade="all, delete-orphan")
			
 
				+    # Per-printer-model preset overrides. Deliberately NOT embedded in
			
 
				+    # SpoolResponse the way k_profiles is: the inventory list returns every
			
 
				+    # spool a user owns, and this list is only ever read by the spool form
			
 
				+    # and the assign path, both of which fetch it for one spool at a time.
			
 
				+    filament_presets: Mapped[list["SpoolFilamentPreset"]] = relationship(
			
 
				+        back_populates="spool", cascade="all, delete-orphan"
			
 
				+    )
			
 
				     assignments: Mapped[list["SpoolAssignment"]] = relationship(back_populates="spool", cascade="all, delete-orphan")
			
 
				     location: Mapped["Location | None"] = relationship(back_populates="spools")
			
 
				 
			
 
				 
			
 
				 from backend.app.models.location import Location  # noqa: E402
			
 
				 from backend.app.models.spool_assignment import SpoolAssignment  # noqa: E402
			
 
				+from backend.app.models.spool_filament_preset import SpoolFilamentPreset  # noqa: E402
			
 
				 from backend.app.models.spool_k_profile import SpoolKProfile  # noqa: E402
			
--- a/backend/app/models/spool_filament_preset.py
+++ b/backend/app/models/spool_filament_preset.py
@@ -0,0 +1,90 @@
 
				+from datetime import datetime
			
 
				+
			
 
				+from sqlalchemy import DateTime, ForeignKey, Integer, String, UniqueConstraint, func
			
 
				+from sqlalchemy.orm import Mapped, mapped_column, relationship
			
 
				+
			
 
				+from backend.app.core.database import Base
			
 
				+
			
 
				+
			
 
				+class SpoolFilamentPreset(Base):
			
 
				+    """Per-printer-model override of a spool's slicer filament preset.
			
 
				+
			
 
				+    ``Spool.slicer_filament`` holds ONE preset, and that is deliberate -- the
			
 
				+    spool form is printer-agnostic and the user picks the variant they want
			
 
				+    (see ``spool-form/utils.ts``). It stops being enough as soon as the same
			
 
				+    spool is used on two different printer models: a cloud or Orca preset is
			
 
				+    bound to a model (``@BBL X1C``), so the spool that carries an X1C variant
			
 
				+    configures an AMS slot on an H2C with a preset that machine has no profile
			
 
				+    for.
			
 
				+
			
 
				+    Keyed on the printer MODEL, not the printer: ``@BBL X1C`` is the same
			
 
				+    preset on every X1C the user owns, and keying per machine would make them
			
 
				+    pick the identical value once per printer. (K profiles are the opposite --
			
 
				+    a K value is measured on one individual hotend -- which is why
			
 
				+    ``spool_k_profile`` keys on ``printer_id`` and this does not.)
			
 
				+
			
 
				+    ``nozzle_diameter`` is part of the key because the preset lands on an AMS
			
 
				+    slot, and a slot feeds exactly one nozzle: on a dual-nozzle machine with
			
 
				+    two different diameters fitted, one preset per model cannot be right for
			
 
				+    both hotends, and diameter-specific presets genuinely exist
			
 
				+    (``Bambu PLA Basic @BBL A1M 0.2 nozzle``). Empty string means "any nozzle
			
 
				+    of this model". The spool form does not write that row -- it offers one row
			
 
				+    per nozzle size and nothing above them, because a preset lands on an AMS
			
 
				+    slot and a slot feeds exactly one nozzle -- but the level is kept in the
			
 
				+    cascade for API clients that want one value to cover a whole model.
			
 
				+    Resolution order is
			
 
				+
			
 
				+        exact (model, diameter) -> (model, "") -> ``Spool.slicer_filament``
			
 
				+
			
 
				+    which is what ``services.spool_filament_preset.resolve_spool_preset``
			
 
				+    implements. Empty string rather than NULL because NULLs compare distinct
			
 
				+    in a UNIQUE constraint on both SQLite and PostgreSQL, so a nullable
			
 
				+    column would happily store the same "any nozzle" row twice.
			
 
				+    """
			
 
				+
			
 
				+    __tablename__ = "spool_filament_preset"
			
 
				+
			
 
				+    __table_args__ = (UniqueConstraint("spool_id", "printer_model", "nozzle_diameter"),)
			
 
				+
			
 
				+    id: Mapped[int] = mapped_column(primary_key=True)
			
 
				+    spool_id: Mapped[int] = mapped_column(ForeignKey("spool.id", ondelete="CASCADE"), index=True)
			
 
				+    # Matches ``printers.model`` ("X1C", "H2D", "A1 mini"), not a display name.
			
 
				+    printer_model: Mapped[str] = mapped_column(String(50))
			
 
				+    # "" = any nozzle of this model; otherwise the bare decimal the printer
			
 
				+    # reports ("0.4", "0.2"), the same form ``spool_k_profile`` stores.
			
 
				+    nozzle_diameter: Mapped[str] = mapped_column(String(10), default="")
			
 
				+    # Wider than ``Spool.slicer_filament`` (String(50)) on purpose: the same
			
 
				+    # values reach the Spoolman path, whose write schema already allows 128 /
			
 
				+    # 255, and a preset id that fits there must not truncate here.
			
 
				+    slicer_filament: Mapped[str | None] = mapped_column(String(128))
			
 
				+    slicer_filament_name: Mapped[str | None] = mapped_column(String(255))
			
 
				+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.now())
			
 
				+
			
 
				+    spool: Mapped["Spool"] = relationship(back_populates="filament_presets")
			
 
				+
			
 
				+
			
 
				+class SpoolmanFilamentPreset(Base):
			
 
				+    """``SpoolFilamentPreset`` for a Spoolman-managed spool.
			
 
				+
			
 
				+    Mirrors ``SpoolmanKProfile``: Spoolman owns the spool, Bambuddy owns this
			
 
				+    override, so the row is local and keyed by the remote spool id with no
			
 
				+    foreign key to enforce it. Kept in a Bambuddy table rather than in the
			
 
				+    spool's Spoolman ``extra`` dict for the same reason the K profiles are --
			
 
				+    it is Bambu-specific data that no other Spoolman client can use, and the
			
 
				+    extra dict cannot express a per-model list without hand-rolled JSON.
			
 
				+    """
			
 
				+
			
 
				+    __tablename__ = "spoolman_filament_preset"
			
 
				+
			
 
				+    __table_args__ = (UniqueConstraint("spoolman_spool_id", "printer_model", "nozzle_diameter"),)
			
 
				+
			
 
				+    id: Mapped[int] = mapped_column(primary_key=True)
			
 
				+    spoolman_spool_id: Mapped[int] = mapped_column(Integer, nullable=False, index=True)
			
 
				+    printer_model: Mapped[str] = mapped_column(String(50))
			
 
				+    nozzle_diameter: Mapped[str] = mapped_column(String(10), default="")
			
 
				+    slicer_filament: Mapped[str | None] = mapped_column(String(128))
			
 
				+    slicer_filament_name: Mapped[str | None] = mapped_column(String(255))
			
 
				+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.now())
			
 
				+
			
 
				+
			
 
				+from backend.app.models.spool import Spool  # noqa: E402, F401
			
--- a/backend/app/schemas/archive.py
+++ b/backend/app/schemas/archive.py
@@ -1,7 +1,7 @@
 
				 from datetime import datetime
			
 
				 from typing import Annotated
			
 
				 
			
 
				-from pydantic import BaseModel, BeforeValidator, model_validator
			
 
				+from pydantic import BaseModel, BeforeValidator, Field, model_validator
			
 
				 
			
 
				 from backend.app.utils.filename import clean_display_name
			
 
				 
			
@@ -28,6 +28,12 @@ class ArchiveUpdate(ArchiveBase):
 
				     project_id: int | None = None
			
 
				     # Allow changing status (e.g., clearing failed flag)
			
 
				     status: str | None = None
			
 
				+    # Editable because a print archived without its 3MF has no figure at all,
			
 
				+    # and nothing else can supply one after the fact -- rescan needs a file
			
 
				+    # this archive does not have (#1820). Bounded because it feeds the filament
			
 
				+    # totals: 100 kg is far past any single print and well short of a value
			
 
				+    # that would swamp a chart.
			
 
				+    filament_used_grams: Annotated[float | None, Field(ge=0, le=100_000)] = None
			
 
				 
			
 
				 
			
 
				 class ArchiveDuplicate(BaseModel):
			
@@ -167,6 +173,10 @@ class ArchiveStats(BaseModel):
 
				     total_cost: float
			
 
				     prints_by_filament_type: dict
			
 
				     prints_by_printer: dict
			
 
				+    # Name each printer id was last recorded under in the print log. Lets the
			
 
				+    # client keep labelling history that belongs to a deleted printer (#2873);
			
 
				+    # a printer that still exists is named from the live record instead.
			
 
				+    printer_names: dict[str, str] = {}
			
 
				     # Time accuracy stats
			
 
				     # Average across all prints with data
			
 
				     average_time_accuracy: float | None = None
			
--- a/backend/app/schemas/location_ha_sensor.py
+++ b/backend/app/schemas/location_ha_sensor.py
@@ -0,0 +1,140 @@
 
				+"""Schemas for Home Assistant entities bound to a storage location (#2824)."""
			
 
				+
			
 
				+from datetime import datetime
			
 
				+from typing import Literal
			
 
				+
			
 
				+from pydantic import BaseModel, Field, model_validator
			
 
				+
			
 
				+from backend.app.schemas.printer_ha_sensor import HADisplayEntity  # noqa: F401
			
 
				+
			
 
				+
			
 
				+class LocationHASensorBase(BaseModel):
			
 
				+    location_id: int
			
 
				+    name: str = Field(..., min_length=1, max_length=100)
			
 
				+    # max_length matches the column (String(255)). The pattern's [a-z0-9_]+ is
			
 
				+    # unbounded, so a direct API caller — the picker only ever offers real
			
 
				+    # Home Assistant ids — could send a longer one: SQLite stores it, but
			
 
				+    # PostgreSQL raises DataError, and the create/update routes only map
			
 
				+    # IntegrityError, so it would surface as a 500 instead of a 422.
			
 
				+    entity_id: str = Field(..., max_length=255, pattern=r"^(binary_sensor|sensor)\.[a-z0-9_]+$")
			
 
				+    kind: Literal["binary", "numeric"] = "binary"
			
 
				+    device_class: str | None = Field(default=None, max_length=32)
			
 
				+    unit: str | None = Field(default=None, max_length=16)
			
 
				+
			
 
				+    alert_state: Literal["on", "off"] | None = None
			
 
				+    # allow_inf_nan=False: pydantic's lax mode coerces the strings "nan"/"inf"
			
 
				+    # into real NaN/Infinity floats. A NaN threshold satisfies the "notify
			
 
				+    # needs an alert condition" rule below yet every comparison against it is
			
 
				+    # False — a notification that can never fire — and it skips the
			
 
				+    # below-vs-above ordering check the same way. Responses serialize NaN as
			
 
				+    # null, so the UI would show an empty field over a poisoned row.
			
 
				+    alert_above: float | None = Field(default=None, allow_inf_nan=False)
			
 
				+    alert_below: float | None = Field(default=None, allow_inf_nan=False)
			
 
				+
			
 
				+    notify_on_alert: bool = False
			
 
				+    show_on_card: bool = True
			
 
				+    sort_order: int = Field(default=0, ge=0, le=999)
			
 
				+
			
 
				+    @model_validator(mode="after")
			
 
				+    def validate_kind_matches_entity(self) -> "LocationHASensorBase":
			
 
				+        domain = self.entity_id.split(".")[0]
			
 
				+        expected = "binary" if domain == "binary_sensor" else "numeric"
			
 
				+        if self.kind != expected:
			
 
				+            raise ValueError(f"kind must be '{expected}' for a {domain} entity")
			
 
				+
			
 
				+        # Alert fields are per-kind: a threshold on a battery sensor and an
			
 
				+        # on/off alert on a temperature reading are both configuration the
			
 
				+        # poller would silently ignore, so reject them at the edge instead.
			
 
				+        if self.kind == "binary" and (self.alert_above is not None or self.alert_below is not None):
			
 
				+            raise ValueError("alert_above/alert_below only apply to numeric sensors")
			
 
				+        if self.kind == "numeric" and self.alert_state is not None:
			
 
				+            raise ValueError("alert_state only applies to binary sensors")
			
 
				+        if self.alert_above is not None and self.alert_below is not None and self.alert_below >= self.alert_above:
			
 
				+            raise ValueError("alert_below must be lower than alert_above")
			
 
				+
			
 
				+        # A notification with nothing to trigger on would never fire — that
			
 
				+        # reads as a broken feature, not as a no-op.
			
 
				+        if self.notify_on_alert and not self._has_alert_condition():
			
 
				+            raise ValueError("notify_on_alert requires an alert condition")
			
 
				+        return self
			
 
				+
			
 
				+    def _has_alert_condition(self) -> bool:
			
 
				+        return self.alert_state is not None or self.alert_above is not None or self.alert_below is not None
			
 
				+
			
 
				+
			
 
				+class LocationHASensorCreate(LocationHASensorBase):
			
 
				+    pass
			
 
				+
			
 
				+
			
 
				+class LocationHASensorUpdate(BaseModel):
			
 
				+    """Partial update. Validated against the merged row in the route, because
			
 
				+    the per-kind rules above need fields this payload may not carry."""
			
 
				+
			
 
				+    name: str | None = Field(default=None, min_length=1, max_length=100)
			
 
				+    # Same column-width bound as the base schema; PATCH reaches the same row.
			
 
				+    entity_id: str | None = Field(default=None, max_length=255, pattern=r"^(binary_sensor|sensor)\.[a-z0-9_]+$")
			
 
				+    kind: Literal["binary", "numeric"] | None = None
			
 
				+    device_class: str | None = Field(default=None, max_length=32)
			
 
				+    unit: str | None = Field(default=None, max_length=16)
			
 
				+    alert_state: Literal["on", "off"] | None = None
			
 
				+    # Same allow_inf_nan story as the base schema. The route's merged-row
			
 
				+    # re-validation would catch these too, but rejecting them here keeps the
			
 
				+    # error attached to the offending field.
			
 
				+    alert_above: float | None = Field(default=None, allow_inf_nan=False)
			
 
				+    alert_below: float | None = Field(default=None, allow_inf_nan=False)
			
 
				+    notify_on_alert: bool | None = None
			
 
				+    show_on_card: bool | None = None
			
 
				+    sort_order: int | None = Field(default=None, ge=0, le=999)
			
 
				+
			
 
				+
			
 
				+class LocationHASensorResponse(LocationHASensorBase):
			
 
				+    # Reads must tolerate what writes now reject, or one legacy row 500s the
			
 
				+    # whole list. Three constraints are relaxed here on purpose:
			
 
				+    #
			
 
				+    # * the NaN/inf thresholds a row could carry before allow_inf_nan landed —
			
 
				+    #   serialization turns them into null, which is also what the edit form
			
 
				+    #   should show;
			
 
				+    # * the entity_id length bound, for a row created before max_length existed
			
 
				+    #   (SQLite never enforced the column's 255, so those rows are real);
			
 
				+    # * the entity_id pattern, which the same generation of rows predates.
			
 
				+    #
			
 
				+    # Every one of them is still rejected on the way in, so this widens what
			
 
				+    # can be read back, never what can be stored.
			
 
				+    alert_above: float | None = None
			
 
				+    alert_below: float | None = None
			
 
				+    entity_id: str
			
 
				+
			
 
				+    id: int
			
 
				+    last_state: str | None = None
			
 
				+    last_changed: datetime | None = None
			
 
				+    last_checked: datetime | None = None
			
 
				+    created_at: datetime
			
 
				+    updated_at: datetime
			
 
				+
			
 
				+    class Config:
			
 
				+        from_attributes = True
			
 
				+
			
 
				+
			
 
				+class LocationHASensorReading(BaseModel):
			
 
				+    """One sensor's live state, as the filament card and inventory table render it."""
			
 
				+
			
 
				+    id: int
			
 
				+    name: str
			
 
				+    entity_id: str
			
 
				+    kind: str
			
 
				+    device_class: str | None = None
			
 
				+    unit: str | None = None
			
 
				+    # Raw HA state: "on"/"off" for binary, the numeric string for sensors.
			
 
				+    # None when the entity is unavailable or has not been polled yet.
			
 
				+    state: str | None = None
			
 
				+    value: float | None = None  # numeric sensors only, parsed from state
			
 
				+    alerting: bool = False
			
 
				+    reachable: bool = True
			
 
				+    alert_state: str | None = None
			
 
				+    alert_above: float | None = None
			
 
				+    alert_below: float | None = None
			
 
				+    last_changed: datetime | None = None
			
 
				+    # Lets a consumer that fetched the unfiltered (show_on_card=False) list
			
 
				+    # still pick out the card-visible subset itself, instead of issuing a
			
 
				+    # second request for the same location.
			
 
				+    show_on_card: bool = True
			
--- a/backend/app/schemas/notification.py
+++ b/backend/app/schemas/notification.py
@@ -3,7 +3,7 @@
 
				 from datetime import datetime
			
 
				 from typing import Any
			
 
				 
			
 
				-from pydantic import BaseModel, Field, field_validator
			
 
				+from pydantic import BaseModel, Field, field_validator, model_validator
			
 
				 
			
 
				 from backend.app.core.compat import StrEnum
			
 
				 
			
@@ -65,11 +65,17 @@ class NotificationProviderBase(BaseModel):
 
				         default=False, description="Notify when AMS-HT temperature exceeds threshold"
			
 
				     )
			
 
				 
			
 
				-    # Event triggers - Home Assistant sensors (#1148)
			
 
				+    # Event triggers - Home Assistant sensors bound to a printer (#1148)
			
 
				     on_ha_sensor_alert: bool = Field(
			
 
				         default=False, description="Notify when a bound Home Assistant sensor enters its alert state"
			
 
				     )
			
 
				 
			
 
				+    # Event triggers - Home Assistant sensors bound to a storage location (#2824)
			
 
				+    on_location_ha_sensor_alert: bool = Field(
			
 
				+        default=False,
			
 
				+        description="Notify when a Home Assistant sensor bound to a storage location enters its alert state",
			
 
				+    )
			
 
				+
			
 
				     # Event triggers - Build plate detection
			
 
				     on_plate_not_empty: bool = Field(default=True, description="Notify when objects detected on plate before print")
			
 
				     on_plate_clear_required: bool = Field(
			
@@ -82,6 +88,19 @@ class NotificationProviderBase(BaseModel):
 
				     # Event triggers - First layer complete
			
 
				     on_first_layer_complete: bool = Field(default=False, description="Notify when first layer completes")
			
 
				 
			
 
				+    # Event triggers - Inventory stock alerts
			
 
				+    # Missing from this schema until now, so every payload naming them was
			
 
				+    # dropped silently: the UI's toggles round-tripped as 200 OK and the row
			
 
				+    # never changed, and _provider_to_dict never returned them either, so they
			
 
				+    # always read back off. The columns and the sending code have existed since
			
 
				+    # the inventory forecast landed.
			
 
				+    on_stock_reorder_alert: bool = Field(
			
 
				+        default=False, description="Notify when an inventory SKU hits its reorder point"
			
 
				+    )
			
 
				+    on_stock_break_alert: bool = Field(
			
 
				+        default=False, description="Notify when stock will run out before replenishment arrives"
			
 
				+    )
			
 
				+
			
 
				     # Event triggers - Print queue
			
 
				     on_queue_job_added: bool = Field(default=False, description="Notify when job is added to queue")
			
 
				     on_queue_job_assigned: bool = Field(default=False, description="Notify when model-based job is assigned to printer")
			
@@ -159,9 +178,12 @@ class NotificationProviderUpdate(BaseModel):
 
				     on_ams_ht_humidity_high: bool | None = None
			
 
				     on_ams_ht_temperature_high: bool | None = None
			
 
				 
			
 
				-    # Event triggers - Home Assistant sensors (#1148)
			
 
				+    # Event triggers - Home Assistant sensors bound to a printer (#1148)
			
 
				     on_ha_sensor_alert: bool | None = None
			
 
				 
			
 
				+    # Event triggers - Home Assistant sensors bound to a storage location (#2824)
			
 
				+    on_location_ha_sensor_alert: bool | None = None
			
 
				+
			
 
				     # Event triggers - Build plate detection
			
 
				     on_plate_not_empty: bool | None = None
			
 
				     on_plate_clear_required: bool | None = None
			
@@ -172,6 +194,10 @@ class NotificationProviderUpdate(BaseModel):
 
				     # Event triggers - First layer complete
			
 
				     on_first_layer_complete: bool | None = None
			
 
				 
			
 
				+    # Event triggers - Inventory stock alerts
			
 
				+    on_stock_reorder_alert: bool | None = None
			
 
				+    on_stock_break_alert: bool | None = None
			
 
				+
			
 
				     # Event triggers - Print queue
			
 
				     on_queue_job_added: bool | None = None
			
 
				     on_queue_job_assigned: bool | None = None
			
@@ -197,6 +223,42 @@ class NotificationProviderUpdate(BaseModel):
 
				 class NotificationProviderResponse(NotificationProviderBase):
			
 
				     """Schema for notification provider API responses."""
			
 
				 
			
 
				+    @model_validator(mode="before")
			
 
				+    @classmethod
			
 
				+    def _null_event_flags_read_as_off(cls, data: Any) -> Any:
			
 
				+        """Read a NULL event flag as off instead of failing the whole response.
			
 
				+
			
 
				+        Every on_* column on notification_providers is nullable with no server
			
 
				+        default -- the values come from the ORM at INSERT time. A row created
			
 
				+        before a flag's column existed keeps NULL there forever unless a
			
 
				+        migration backfills it, and one that did not (the column was created by
			
 
				+        Base.metadata before run_migrations, so the ALTER ... DEFAULT false was
			
 
				+        swallowed as a duplicate) leaves NULLs behind on a live install.
			
 
				+
			
 
				+        Those NULLs are harmless until the flag is declared on this schema: the
			
 
				+        Response inherits the write model, so `bool` is then required on the way
			
 
				+        out, pydantic rejects None, and every provider row fails at once -- the
			
 
				+        list route 500s and the UI renders an empty list, which reads to the user
			
 
				+        as "my providers are gone". That is exactly what shipped in #2827.
			
 
				+
			
 
				+        Off is not a guess: _get_providers_for_event selects on `.is_(True)`, so
			
 
				+        the sender already skips a NULL flag. This makes the read agree with the
			
 
				+        behaviour the row already has, rather than with the field's declared
			
 
				+        default -- some of which are True, and none of which should switch a
			
 
				+        notification on as a side effect of repairing a legacy row.
			
 
				+
			
 
				+        Writes are untouched: Create and Update inherit from the base, not here,
			
 
				+        so a payload sending null for a flag is still a 422.
			
 
				+        """
			
 
				+        # Every route returns _provider_to_dict(); anything else (an ORM object
			
 
				+        # via from_attributes) is passed through for pydantic to handle.
			
 
				+        if not isinstance(data, dict):
			
 
				+            return data
			
 
				+        flags = [name for name, f in cls.model_fields.items() if f.annotation is bool]
			
 
				+        if any(data.get(name, False) is None for name in flags):
			
 
				+            data = {**data, **{name: False for name in flags if data.get(name, False) is None}}
			
 
				+        return data
			
 
				+
			
 
				     id: int
			
 
				     last_success: datetime | None = None
			
 
				     last_error: str | None = None
			
--- a/backend/app/schemas/notification_template.py
+++ b/backend/app/schemas/notification_template.py
@@ -91,6 +91,7 @@ EVENT_VARIABLES: dict[str, list[str]] = {
 
				     ],
			
 
				     "bed_cooled": ["printer", "bed_temp", "threshold", "filename", "timestamp", "app_name"],
			
 
				     "ha_sensor_alert": ["printer", "sensor", "state", "timestamp", "app_name"],
			
 
				+    "location_ha_sensor_alert": ["location", "sensor", "state", "timestamp", "app_name"],
			
 
				     "test": ["app_name", "timestamp"],
			
 
				     # Queue notifications
			
 
				     "queue_job_added": ["job_name", "target", "timestamp", "app_name"],
			
@@ -243,6 +244,13 @@ SAMPLE_DATA: dict[str, dict[str, str]] = {
 
				         "timestamp": "2024-01-15 14:30",
			
 
				         "app_name": "Bambuddy",
			
 
				     },
			
 
				+    "location_ha_sensor_alert": {
			
 
				+        "location": "Drybox 1",
			
 
				+        "sensor": "Drybox 1 Humidity",
			
 
				+        "state": "68.00 %",
			
 
				+        "timestamp": "2024-01-15 14:30",
			
 
				+        "app_name": "Bambuddy",
			
 
				+    },
			
 
				     "test": {
			
 
				         "app_name": "Bambuddy",
			
 
				         "timestamp": "2024-01-15 14:30",
			
--- a/backend/app/schemas/print_queue.py
+++ b/backend/app/schemas/print_queue.py
@@ -444,6 +444,9 @@ class PrintBatchPlateProgress(BaseModel):
 
				     estimated_remaining_cost: float | None = None
			
 
				     filament_used_grams: float | None = None
			
 
				     print_time_seconds: int = 0
			
 
				+    # False when this plate owes runs but has no queue item left to clone
			
 
				+    # their configuration from, so offering to queue it would only fail.
			
 
				+    can_dispatch: bool = False
			
 
				 
			
 
				 
			
 
				 class PrintBatchResponse(BaseModel):
			
@@ -475,6 +478,9 @@ class PrintBatchResponse(BaseModel):
 
				     has_targets: bool = False
			
 
				     target_count: int = 0
			
 
				     remaining_count: int = 0
			
 
				+    # Of ``remaining_count``, how many runs can actually be queued. Lower when
			
 
				+    # a plate's last queue item was deleted (#2960).
			
 
				+    dispatchable_count: int = 0
			
 
				     actual_cost: float | None = None
			
 
				     estimated_remaining_cost: float | None = None
			
 
				     filament_used_grams: float | None = None
			
--- a/backend/app/schemas/printer.py
+++ b/backend/app/schemas/printer.py
@@ -1,6 +1,6 @@
 
				 from datetime import datetime
			
 
				 
			
 
				-from pydantic import BaseModel, Field, field_validator
			
 
				+from pydantic import BaseModel, Field, field_validator, model_validator
			
 
				 
			
 
				 from backend.app.utils.printer_models import supports_nozzle_flow_type
			
 
				 
			
@@ -170,6 +170,15 @@ class HMSErrorResponse(BaseModel):
 
				     # truncated short_code that historically caused silent command rejection
			
 
				     # (#1830, H2D wrong-plate verification).
			
 
				     full_code: str = ""
			
 
				+    # The bundled catalogue's sentence for this fault, so a client does not have
			
 
				+    # to carry its own copy of the same table to tell a user why a print halted
			
 
				+    # (#2926). English only and not localized — the catalogue ships one language.
			
 
				+    # None when the catalogue does not cover the code, which is common for
			
 
				+    # `hms[]`-array faults: those resolve through a lossy collapse of their
			
 
				+    # 16-char identifier and many land on no key at all (#2728). A client should
			
 
				+    # treat null as "no text available", never as "no fault" — `full_code` is
			
 
				+    # what identifies the fault, and it is always present.
			
 
				+    description: str | None = None
			
 
				 
			
 
				 
			
 
				 class AMSTray(BaseModel):
			
@@ -267,6 +276,25 @@ class FilaSwitchResponse(BaseModel):
 
				     out_extruders: list[int] = []
			
 
				     stat: int = 0
			
 
				     info: int = 0
			
 
				+    # Whether the switch is set up: every AMS bound to one of its two inlets.
			
 
				+    # A load cannot be routed until it is, so the UI blocks on this rather than
			
 
				+    # sending a command the firmware will drop.
			
 
				+    ready: bool = False
			
 
				+
			
 
				+
			
 
				+class ExtruderSlotResponse(BaseModel):
			
 
				+    """Which AMS slot one hotend is currently fed from.
			
 
				+
			
 
				+    From ``device.extruder.info[i].snow``. Needed because ``tray_now`` is a
			
 
				+    single printer-wide value: on a dual-nozzle machine with both hotends
			
 
				+    loaded it names only one of them, so it cannot say which hotend holds a
			
 
				+    given slot.
			
 
				+    """
			
 
				+
			
 
				+    # None when the hotend is not fed from any slot.
			
 
				+    ams_id: int | None = None
			
 
				+    slot_id: int | None = None
			
 
				+    has_filament: bool = False
			
 
				 
			
 
				 
			
 
				 class PrintOptionsResponse(BaseModel):
			
@@ -338,6 +366,16 @@ class PrinterStatus(BaseModel):
 
				     # Filament Track Switch (FTS) accessory — when installed, AMS reports
			
 
				     # bits 8-11 = 0xE (uninitialized) and routing is dynamic via the FTS. See #1162.
			
 
				     fila_switch: FilaSwitchResponse | None = None
			
 
				+    # Per-AMS FTS inlet binding: {ams_id: "A" | "B"}, from AMS info bits 24-27.
			
 
				+    # Which of the switch's two inlets each AMS is plumbed into, as set on the
			
 
				+    # printer's "Manual AMS Setup" screen. Empty unless an FTS is installed —
			
 
				+    # an FTS-bound AMS reaches BOTH nozzles, so it has no entry in
			
 
				+    # ams_extruder_map and must not be labelled left or right.
			
 
				+    ams_switch_inlet: dict[str, str] = {}
			
 
				+    # Which AMS slot each hotend is fed from, keyed by extruder id as a string
			
 
				+    # ("0" = right/main, "1" = left/deputy). Empty on printers that do not
			
 
				+    # report ``device.extruder.info``.
			
 
				+    extruder_slots: dict[str, ExtruderSlotResponse] = {}
			
 
				     # Currently loaded tray (global ID): 254 = external spool, 255 = no filament
			
 
				     tray_now: int = 255
			
 
				     # Runout / filament-replacement guidance (#2587). Populated only while the
			
@@ -439,3 +477,27 @@ class DiagnosticRequest(BaseModel):
 
				     ip_address: str
			
 
				     serial_number: str | None = None
			
 
				     access_code: str | None = None
			
 
				+
			
 
				+
			
 
				+class PrinterFilesDownloadRequest(BaseModel):
			
 
				+    """Printer paths selected for a bulk download."""
			
 
				+
			
 
				+    paths: list[str] = Field(..., max_length=1000)
			
 
				+    sizes: dict[str, int] = Field(default_factory=dict, max_length=1000)
			
 
				+
			
 
				+    @model_validator(mode="after")
			
 
				+    def _validate_sizes(self):
			
 
				+        """Validate optional FTP-reported sizes used for early rejection."""
			
 
				+
			
 
				+        if self.sizes and set(self.sizes) != set(self.paths):
			
 
				+            raise ValueError("A size is required for every selected printer path")
			
 
				+        if any(size < 0 for size in self.sizes.values()):
			
 
				+            raise ValueError("Printer file sizes must not be negative")
			
 
				+        return self
			
 
				+
			
 
				+
			
 
				+class PrinterFilesJobRequest(PrinterFilesDownloadRequest):
			
 
				+    """Browser preparation request, including native download presentation."""
			
 
				+
			
 
				+    filename: str = Field(default="printer-files.zip", min_length=1, max_length=255)
			
 
				+    as_zip: bool = True
			
--- a/backend/app/schemas/printer_ha_sensor.py
+++ b/backend/app/schemas/printer_ha_sensor.py
@@ -9,7 +9,11 @@ from pydantic import BaseModel, Field, model_validator
 
				 class PrinterHASensorBase(BaseModel):
			
 
				     printer_id: int
			
 
				     name: str = Field(..., min_length=1, max_length=100)
			
 
				-    entity_id: str = Field(..., pattern=r"^(binary_sensor|sensor)\.[a-z0-9_]+$")
			
 
				+    # max_length matches the column (String(255)). The pattern's [a-z0-9_]+ is
			
 
				+    # unbounded, so a direct API caller could send a longer id: SQLite stores
			
 
				+    # it, PostgreSQL raises DataError, and it would surface as a 500 rather
			
 
				+    # than a 422. Same bound as the location sibling.
			
 
				+    entity_id: str = Field(..., max_length=255, pattern=r"^(binary_sensor|sensor)\.[a-z0-9_]+$")
			
 
				     kind: Literal["binary", "numeric"] = "binary"
			
 
				     device_class: str | None = Field(default=None, max_length=32)
			
 
				     unit: str | None = Field(default=None, max_length=16)
			
@@ -59,7 +63,8 @@ class PrinterHASensorUpdate(BaseModel):
 
				     the per-kind rules above need fields this payload may not carry."""
			
 
				 
			
 
				     name: str | None = Field(default=None, min_length=1, max_length=100)
			
 
				-    entity_id: str | None = Field(default=None, pattern=r"^(binary_sensor|sensor)\.[a-z0-9_]+$")
			
 
				+    # Same column-width bound as the base schema; PATCH reaches the same row.
			
 
				+    entity_id: str | None = Field(default=None, max_length=255, pattern=r"^(binary_sensor|sensor)\.[a-z0-9_]+$")
			
 
				     kind: Literal["binary", "numeric"] | None = None
			
 
				     device_class: str | None = Field(default=None, max_length=32)
			
 
				     unit: str | None = Field(default=None, max_length=16)
			
@@ -73,6 +78,14 @@ class PrinterHASensorUpdate(BaseModel):
 
				 
			
 
				 
			
 
				 class PrinterHASensorResponse(PrinterHASensorBase):
			
 
				+    # Reads stay tolerant of what writes now reject: this feature shipped
			
 
				+    # before entity_id was bounded, and SQLite never enforced the column's 255,
			
 
				+    # so a row longer than that can genuinely exist. Inheriting the bound would
			
 
				+    # turn it into a 500 on the list route — the same failure the bound was
			
 
				+    # added to prevent, moved from the write path to the read path. The pattern
			
 
				+    # is dropped with it, for the same generation of rows. Writes are unchanged.
			
 
				+    entity_id: str
			
 
				+
			
 
				     id: int
			
 
				     last_state: str | None = None
			
 
				     last_changed: datetime | None = None
			
--- a/backend/app/schemas/scheduled_drying.py
+++ b/backend/app/schemas/scheduled_drying.py
@@ -0,0 +1,43 @@
 
				+from datetime import datetime
			
 
				+from typing import Annotated
			
 
				+
			
 
				+from pydantic import AfterValidator, BaseModel, Field
			
 
				+
			
 
				+from backend.app.schemas.print_queue import UTCDatetime
			
 
				+from backend.app.utils.local_time import to_naive_utc
			
 
				+
			
 
				+# Coerces any client-sent UTC offset to the naive UTC the DB stores.
			
 
				+NaiveUTCDatetime = Annotated[datetime | None, AfterValidator(to_naive_utc)]
			
 
				+
			
 
				+
			
 
				+class ScheduledDryingCreate(BaseModel):
			
 
				+    printer_id: int
			
 
				+    ams_id: int = 0
			
 
				+    temp: int = Field(ge=45, le=85)
			
 
				+    duration_hours: int = Field(ge=1, le=24)
			
 
				+    # max_length matches the String(50) column: without it PostgreSQL 500s on
			
 
				+    # an over-long value and SQLite silently accepts it.
			
 
				+    filament: str = Field("", max_length=50)
			
 
				+    rotate_tray: bool = False
			
 
				+    start_after: NaiveUTCDatetime = None
			
 
				+
			
 
				+
			
 
				+class ScheduledDryingResponse(BaseModel):
			
 
				+    id: int
			
 
				+    printer_id: int
			
 
				+    ams_id: int
			
 
				+    temp: int
			
 
				+    duration_hours: int
			
 
				+    filament: str
			
 
				+    rotate_tray: bool
			
 
				+    # UTCDatetime, not a bare datetime: every queue route sends the Z suffix and
			
 
				+    # the frontend parses these the same way.
			
 
				+    start_after: UTCDatetime
			
 
				+    status: str
			
 
				+    waiting_reason: str | None
			
 
				+    error_message: str | None
			
 
				+    created_at: UTCDatetime
			
 
				+    started_at: UTCDatetime
			
 
				+    completed_at: UTCDatetime
			
 
				+
			
 
				+    model_config = {"from_attributes": True}
			
--- a/backend/app/schemas/settings.py
+++ b/backend/app/schemas/settings.py
@@ -115,6 +115,18 @@ class AppSettings(BaseModel):
 
				     ams_temp_fair: float = Field(
			
 
				         default=35.0, description="Temperature threshold for fair (orange): <= this value, > is red"
			
 
				     )
			
 
				+    # Separate from ams_temp_fair on purpose (#2905). The fair threshold decides
			
 
				+    # when the AMS card turns amber; this decides when a notification is sent.
			
 
				+    # 35 C is a sensible place to change a colour and not a sensible place to
			
 
				+    # page someone -- a room above 35 C makes the alarm fire once an hour for as
			
 
				+    # long as the weather lasts, and the only way to silence it was to raise the
			
 
				+    # display band and lose the colour that says the unit is warm. None means
			
 
				+    # "not set", which resolves to ams_temp_fair so every existing install keeps
			
 
				+    # behaving exactly as it does now.
			
 
				+    ams_temp_alarm: float | None = Field(
			
 
				+        default=None,
			
 
				+        description="Temperature threshold (°C) for sending an alarm. Unset falls back to ams_temp_fair.",
			
 
				+    )
			
 
				     ams_history_retention_days: int = Field(default=30, description="Number of days to keep AMS sensor history data")
			
 
				     printer_sensor_history_retention_days: int = Field(
			
 
				         default=30, description="Number of days to keep printer heater history data (nozzle / bed / chamber)"
			
@@ -606,6 +618,27 @@ class AppSettings(BaseModel):
 
				         description="Global lead time floor (days) used in reorder point calculation for all SKUs",
			
 
				     )
			
 
				 
			
 
				+    location_sensor_poll_interval: int = Field(
			
 
				+        default=120,
			
 
				+        ge=60,
			
 
				+        le=3600,
			
 
				+        description="Seconds between Home Assistant polls/UI refreshes for storage-location sensors",
			
 
				+    )
			
 
				+    # Server-backed rather than per-browser: these seed the alert rule written
			
 
				+    # onto each sensor row when one is bound, so two admins binding sensors
			
 
				+    # from different browsers must not seed different rules — and a restore
			
 
				+    # has to bring them back. The "show on card" default stays local, because
			
 
				+    # show_on_card is decided per sensor and this is only its form
			
 
				+    # pre-selection. Same JSON-in-a-string shape as preheat_filament_targets.
			
 
				+    location_sensor_alert_defaults: str = Field(
			
 
				+        default="",
			
 
				+        description=(
			
 
				+            "JSON map of sensor category (temperature/humidity/battery) → "
			
 
				+            '{"alertAbove": str, "alertBelow": str, "notifyOnAlert": bool}, seeding new '
			
 
				+            "storage-location sensor bindings. Empty = built-in defaults."
			
 
				+        ),
			
 
				+    )
			
 
				+
			
 
				     # Default sidebar order (admin-set for all users)
			
 
				     default_sidebar_order: str = Field(
			
 
				         default="",
			
@@ -643,6 +676,7 @@ class AppSettingsUpdate(BaseModel):
 
				     ams_humidity_fair: int | None = None
			
 
				     ams_temp_good: float | None = None
			
 
				     ams_temp_fair: float | None = None
			
 
				+    ams_temp_alarm: float | None = None
			
 
				     ams_history_retention_days: int | None = None
			
 
				     printer_sensor_history_retention_days: int | None = None
			
 
				     queue_drying_enabled: bool | None = None
			
@@ -748,6 +782,12 @@ class AppSettingsUpdate(BaseModel):
 
				     obico_enabled_printers: str | None = None
			
 
				     default_sidebar_order: str | None = None
			
 
				     forecast_global_lead_time_days: int | None = Field(default=None, ge=0)
			
 
				+    location_sensor_poll_interval: int | None = Field(default=None, ge=60, le=3600)
			
 
				+    # Three categories × three short fields is well under 300 characters of
			
 
				+    # JSON, so 2000 is pure headroom — the cap only stops a stray client from
			
 
				+    # parking megabytes in the settings table. Write path only: the AppSettings
			
 
				+    # read model must keep accepting whatever an older install already stored.
			
 
				+    location_sensor_alert_defaults: str | None = Field(default=None, max_length=2000)
			
 
				 
			
 
				     @field_validator(*LAN_SERVICE_URL_SETTINGS)
			
 
				     @classmethod
			
--- a/backend/app/schemas/slicer.py
+++ b/backend/app/schemas/slicer.py
@@ -1,9 +1,15 @@
 
				 """Pydantic schemas for slice requests."""
			
 
				 
			
 
				+import re
			
 
				 from typing import Any, Literal
			
 
				 
			
 
				 from pydantic import BaseModel, Field, model_validator
			
 
				 
			
 
				+# `#RRGGBB` or `#RRGGBBAA`. Bambu Studio writes the 6-digit form into
			
 
				+# `filament_colour` but accepts and round-trips the 8-digit one, and the AMS
			
 
				+# reports colours with an alpha byte, so both have to pass.
			
 
				+_HEX_COLOUR = re.compile(r"#(?:[0-9a-fA-F]{6}|[0-9a-fA-F]{8})")
			
 
				+
			
 
				 
			
 
				 class PresetRef(BaseModel):
			
 
				     """A source-aware reference to a printer / process / filament preset.
			
@@ -67,6 +73,34 @@ class SliceRequest(BaseModel):
 
				     # is empty so older clients keep working.
			
 
				     filament_presets: list[PresetRef] = Field(default_factory=list)
			
 
				 
			
 
				+    # Per-slot filament colour, plate-slot-ordered like ``filament_presets``.
			
 
				+    # Neither Bambu Studio nor OrcaSlicer store a colour on a *filament preset*
			
 
				+    # — it is a per-project property their GUIs set from the plate — so the CLI
			
 
				+    # falls back to its compiled-in default (#00AE42, Bambu green) for every
			
 
				+    # slice unless something supplies one. That default is what #2977 saw: a
			
 
				+    # green plate thumbnail, `filament_colour = #00AE42` in the output, and a
			
 
				+    # "Color mismatch" against the AMS slot the print was mapped to.
			
 
				+    #
			
 
				+    # `default_filament_colour` is NOT a substitute. Measured against a
			
 
				+    # 02.08.02.61 sidecar: sending it alone leaves `filament_colour` at
			
 
				+    # #00AE42, because the CLI never reads it — it is consumed by the GUI when
			
 
				+    # initialising a project. The colour has to be written to `filament_colour`
			
 
				+    # itself, which is what this field ends up doing.
			
 
				+    filament_colours: list[str] = Field(
			
 
				+        default_factory=list,
			
 
				+        description=(
			
 
				+            "Per-slot filament colour as ``#RRGGBB`` / ``#RRGGBBAA``, in the same "
			
 
				+            "plate-slot order as ``filament_presets``. Written onto each resolved "
			
 
				+            "filament profile as ``filament_colour`` so the sliced file records the "
			
 
				+            "colour actually being printed instead of the slicer's built-in default "
			
 
				+            "(#2977). A shorter list than ``filament_presets`` leaves the remaining "
			
 
				+            "slots to the fallback chain; an empty string in any position does the "
			
 
				+            "same for that one slot. An omitted list (older clients) falls back to "
			
 
				+            "the preset's own ``default_filament_colour``, then to the colour the "
			
 
				+            "source file's plate was designed with."
			
 
				+        ),
			
 
				+    )
			
 
				+
			
 
				     plate: int | None = Field(
			
 
				         default=None,
			
 
				         ge=0,
			
@@ -90,7 +124,11 @@ class SliceRequest(BaseModel):
 
				             "preset (#2622) — the designer's own wall count, infill, first-layer "
			
 
				             "height and so on, which ``--load-settings`` would otherwise discard. "
			
 
				             "Only keys the source actually lists as changed are applied; anything "
			
 
				-            "else is ignored. ``None``/empty means a plain profile slice."
			
 
				+            "else is ignored. An empty list is not the same answer as ``None``: "
			
 
				+            "it says the caller was shown the file's settings and chose none of "
			
 
				+            "them, which also holds back the support carry-over (#1881) for the "
			
 
				+            "support keys the file offered, while ``None`` — a caller that "
			
 
				+            "predates the per-key choice — leaves that carry-over unconditional."
			
 
				         ),
			
 
				     )
			
 
				     process_overrides: dict[str, Any] | None = Field(
			
@@ -197,6 +235,23 @@ class SliceRequest(BaseModel):
 
				             # Multi-color caller: backfill the singular from the first slot
			
 
				             # so callers that still read the legacy field see a stable value.
			
 
				             self.filament_preset = self.filament_presets[0]
			
 
				+
			
 
				+        # Colours are pasted straight into a profile the slicer parses, so a
			
 
				+        # malformed one is rejected here rather than passed through. Empty
			
 
				+        # strings survive: they are how a caller says "no colour for this
			
 
				+        # slot" without having to shorten the list and shift every slot after
			
 
				+        # it. Normalised to upper-case so a slice never differs from another
			
 
				+        # only by the case of a hex digit.
			
 
				+        normalised: list[str] = []
			
 
				+        for i, colour in enumerate(self.filament_colours):
			
 
				+            value = (colour or "").strip()
			
 
				+            if not value:
			
 
				+                normalised.append("")
			
 
				+                continue
			
 
				+            if not _HEX_COLOUR.fullmatch(value):
			
 
				+                raise ValueError(f"filament_colours[{i}] must be '#RRGGBB' or '#RRGGBBAA', got {colour!r}")
			
 
				+            normalised.append("#" + value[1:].upper())
			
 
				+        self.filament_colours = normalised
			
 
				         return self
			
 
				 
			
 
				 
			
--- a/backend/app/schemas/spool.py
+++ b/backend/app/schemas/spool.py
@@ -198,6 +198,31 @@ class SpoolKProfileResponse(SpoolKProfileBase):
 
				         from_attributes = True
			
 
				 
			
 
				 
			
 
				+class SpoolFilamentPresetBase(BaseModel):
			
 
				+    """One per-printer-model slicer preset override for a spool.
			
 
				+
			
 
				+    ``nozzle_diameter`` defaults to "" meaning "any nozzle of this model". The
			
 
				+    spool form always sends a concrete size; the empty form is for API clients
			
 
				+    that want one value to cover a model. Lengths match the columns, which are wider than
			
 
				+    ``Spool.slicer_filament`` so a preset id that fits the Spoolman write
			
 
				+    schema cannot truncate on the way in.
			
 
				+    """
			
 
				+
			
 
				+    printer_model: str = Field(..., min_length=1, max_length=50)
			
 
				+    nozzle_diameter: str = Field(default="", max_length=10)
			
 
				+    slicer_filament: str | None = Field(default=None, max_length=128)
			
 
				+    slicer_filament_name: str | None = Field(default=None, max_length=255)
			
 
				+
			
 
				+
			
 
				+class SpoolFilamentPresetResponse(SpoolFilamentPresetBase):
			
 
				+    id: int
			
 
				+    spool_id: int
			
 
				+    created_at: datetime
			
 
				+
			
 
				+    class Config:
			
 
				+        from_attributes = True
			
 
				+
			
 
				+
			
 
				 class SpoolResponse(SpoolBase):
			
 
				     id: int
			
 
				     # rgba is intentionally unconstrained on the response side: the write paths
			
--- a/backend/app/services/archive.py
+++ b/backend/app/services/archive.py
@@ -18,8 +18,11 @@ from backend.app.core.tasks import spawn_background_task
 
				 from backend.app.models.archive import PrintArchive
			
 
				 from backend.app.models.filament import Filament
			
 
				 from backend.app.models.printer import Printer
			
 
				+from backend.app.utils.archive_paths import archive_dir as resolve_archive_dir
			
 
				+from backend.app.utils.ffmpeg_output import NO_FFMPEG_OUTPUT, summarize_ffmpeg_stderr
			
 
				 from backend.app.utils.filename import clean_display_name
			
 
				-from backend.app.utils.safe_path import PathTraversalError, safe_join_under
			
 
				+from backend.app.utils.safe_path import PathTraversalError, assert_under, safe_join_under
			
 
				+from backend.app.utils.threemf_tools import bed_temperature_from_config
			
 
				 
			
 
				 logger = logging.getLogger(__name__)
			
 
				 
			
@@ -89,6 +92,25 @@ def _read_plate_index(plate) -> int | None:
 
				     return None
			
 
				 
			
 
				 
			
 
				+def plate_indexes_in_3mf(file_path: Path) -> list[int | None]:
			
 
				+    """Return one entry per ``<plate>`` a Bambu 3MF declares, in file order.
			
 
				+
			
 
				+    Reads only ``Metadata/slice_info.config``. An entry is None when that plate
			
 
				+    carries no readable index, and the list is empty for a file that could not
			
 
				+    be read at all — callers must not confuse either with "this file has plates
			
 
				+    and yours is not among them". An unreadable 3MF is a parse this code does
			
 
				+    not understand, not evidence about which plate it holds (#2957).
			
 
				+    """
			
 
				+    try:
			
 
				+        with zipfile.ZipFile(file_path, "r") as zf:
			
 
				+            if "Metadata/slice_info.config" not in zf.namelist():
			
 
				+                return []
			
 
				+            root = ET.fromstring(zf.read("Metadata/slice_info.config").decode())
			
 
				+            return [_read_plate_index(plate) for plate in root.findall(".//plate")]
			
 
				+    except Exception:
			
 
				+        return []
			
 
				+
			
 
				+
			
 
				 def peek_plate_index_in_3mf(file_path: Path) -> int | None:
			
 
				     """Return the plate index a single-plate Bambu 3MF represents, or None.
			
 
				 
			
@@ -102,18 +124,8 @@ def peek_plate_index_in_3mf(file_path: Path) -> int | None:
 
				     plate 1 out of such a file, declaring a mismatch against the plate that
			
 
				     is really running, and discarding a perfectly good 3MF (#2522).
			
 
				     """
			
 
				-    try:
			
 
				-        with zipfile.ZipFile(file_path, "r") as zf:
			
 
				-            if "Metadata/slice_info.config" not in zf.namelist():
			
 
				-                return None
			
 
				-            content = zf.read("Metadata/slice_info.config").decode()
			
 
				-            root = ET.fromstring(content)
			
 
				-            plates = root.findall(".//plate")
			
 
				-            if len(plates) != 1:
			
 
				-                return None
			
 
				-            return _read_plate_index(plates[0])
			
 
				-    except Exception:
			
 
				-        return None
			
 
				+    plates = plate_indexes_in_3mf(file_path)
			
 
				+    return plates[0] if len(plates) == 1 else None
			
 
				 
			
 
				 
			
 
				 _PLATE_SUFFIX_RE = re.compile(r"^(.*?)(\s*-\s*Plate\s+|_plate_)(\d+)$", re.IGNORECASE)
			
@@ -138,6 +150,14 @@ def swap_plate_suffix(name: str | None, target_plate: int) -> str | None:
 
				     return f"{base}{separator}{target_plate}"
			
 
				 
			
 
				 
			
 
				+# How much of a plate's G-code to scan for header/config values. The header
			
 
				+# block ends in the first kilobyte; the CONFIG_BLOCK that follows it carries
			
 
				+# layer_height 14-25KB in (measured across the sliced 3MFs on hand, Bambu
			
 
				+# Studio and OrcaSlicer alike), so 4KB — what this used to read — could only
			
 
				+# ever see the header.
			
 
				+_GCODE_SCAN_BYTES = 64 * 1024
			
 
				+
			
 
				+
			
 
				 class ThreeMFParser:
			
 
				     """Parser for Bambu Lab 3MF files."""
			
 
				 
			
@@ -347,24 +367,65 @@ class ThreeMFParser:
 
				         except Exception:
			
 
				             pass  # Skip unreadable project settings file
			
 
				 
			
 
				+    def _printed_plate_gcode(self, gcode_files: list[str]) -> str:
			
 
				+        """Return the G-code entry for the plate this archive is about.
			
 
				+
			
 
				+        ``plate_number`` is known for a plate-specific export (slice_info sets
			
 
				+        it) and picking blindly is wrong there: a project sliced with plate 2
			
 
				+        at 0.08 and plate 1 at 0.2 would otherwise report plate 1's numbers.
			
 
				+        Falls back to the lowest plate index, then to zip order, so a file
			
 
				+        whose entries are named some other way still parses as it did before.
			
 
				+        """
			
 
				+        if self.plate_number:
			
 
				+            wanted = f"Metadata/plate_{self.plate_number}.gcode"
			
 
				+            if wanted in gcode_files:
			
 
				+                return wanted
			
 
				+
			
 
				+        def plate_index(name: str) -> int:
			
 
				+            match = re.search(r"plate_(\d+)\.gcode$", name)
			
 
				+            return int(match.group(1)) if match else 10**6
			
 
				+
			
 
				+        return min(gcode_files, key=lambda name: (plate_index(name), gcode_files.index(name)))
			
 
				+
			
 
				     def _parse_gcode_header(self, zf: zipfile.ZipFile):
			
 
				-        """Parse G-code file header for total layer count and printer model."""
			
 
				+        """Parse the printed plate's G-code for what only it can settle.
			
 
				+
			
 
				+        The plate's own G-code is the file the printer executes, so where it
			
 
				+        disagrees with ``project_settings.config`` — the *project's* record,
			
 
				+        which a multi-plate or per-plate-modified export can leave describing
			
 
				+        a different plate entirely — the G-code wins.
			
 
				+        """
			
 
				         try:
			
 
				-            # Look for plate_1.gcode or similar
			
 
				             gcode_files = [f for f in zf.namelist() if f.endswith(".gcode")]
			
 
				             if not gcode_files:
			
 
				                 return
			
 
				 
			
 
				-            # Read first 4KB of G-code (header contains metadata)
			
 
				-            gcode_path = gcode_files[0]
			
 
				+            gcode_path = self._printed_plate_gcode(gcode_files)
			
 
				+            # 64KB, not 4KB: the header block ends within the first kilobyte,
			
 
				+            # but the CONFIG_BLOCK that carries layer_height starts right after
			
 
				+            # it and the keys are alphabetical, so layer_height lands 14-25KB
			
 
				+            # in on real files. The read is decompress-on-demand, so the cost
			
 
				+            # of the wider window is a few tens of KB per archived file.
			
 
				             with zf.open(gcode_path) as f:
			
 
				-                header = f.read(4096).decode("utf-8", errors="ignore")
			
 
				+                header = f.read(_GCODE_SCAN_BYTES).decode("utf-8", errors="ignore")
			
 
				 
			
 
				             # Look for "; total layer number: XX" pattern
			
 
				             match = re.search(r";\s*total\s+layer\s+number[:\s]+(\d+)", header, re.IGNORECASE)
			
 
				             if match:
			
 
				                 self.metadata["total_layers"] = int(match.group(1))
			
 
				 
			
 
				+            # Layer height, overriding project_settings.config when both are
			
 
				+            # present. The project config records the project's settings and can
			
 
				+            # describe a plate other than this one; the plate's G-code is what
			
 
				+            # the printer executes, so it decides. Anchored to the line start so keys ending in
			
 
				+            # "layer_height" (independent_support_layer_height) can't match.
			
 
				+            match = re.search(r"^;\s*layer_height\s*=\s*([\d.]+)\s*$", header, re.IGNORECASE | re.MULTILINE)
			
 
				+            if match:
			
 
				+                try:
			
 
				+                    self.metadata["layer_height"] = float(match.group(1))
			
 
				+                except ValueError:
			
 
				+                    pass  # Malformed value: keep whatever project_settings gave us
			
 
				+
			
 
				             # Total filament usage. The slicer writes the print's totals into
			
 
				             # the G-code header ("; total filament weight [g] : 126.26"). Only
			
 
				             # a fallback — slice_info.config is more authoritative when present
			
@@ -448,15 +509,14 @@ class ThreeMFParser:
 
				                 elif isinstance(val, (int, float, str)):
			
 
				                     self.metadata["nozzle_diameter"] = float(val)
			
 
				 
			
 
				-            # Bed temperature - first layer or regular
			
 
				-            for key in ["bed_temperature_initial_layer", "bed_temperature"]:
			
 
				-                if key in data:
			
 
				-                    val = data[key]
			
 
				-                    if isinstance(val, list) and val:
			
 
				-                        self.metadata["bed_temperature"] = int(float(val[0]))
			
 
				-                    elif isinstance(val, (int, float, str)):
			
 
				-                        self.metadata["bed_temperature"] = int(float(val))
			
 
				-                    break
			
 
				+            # Bed temperature, for the plate this project is sliced for. This
			
 
				+            # used to look for `bed_temperature` alone, a key BambuStudio does
			
 
				+            # not write -- so every archive from a Bambu slice stored NULL, and
			
 
				+            # preheat fell back to a configured bed temperature on every job
			
 
				+            # (#2989). Orca-exported 3MFs keep working through the generic keys.
			
 
				+            bed_temperature = bed_temperature_from_config(data)
			
 
				+            if bed_temperature is not None:
			
 
				+                self.metadata["bed_temperature"] = bed_temperature
			
 
				 
			
 
				             # Nozzle temperature
			
 
				             for key in ["nozzle_temperature_initial_layer", "nozzle_temperature"]:
			
@@ -483,30 +543,6 @@ class ThreeMFParser:
 
				         except Exception:
			
 
				             pass  # Print settings are optional; missing values are left unset
			
 
				 
			
 
				-    def _extract_settings_from_content(self, content: str):
			
 
				-        """Extract print settings from config content."""
			
 
				-        settings_map = {
			
 
				-            "layer_height": ("layer_height", float),
			
 
				-            "nozzle_diameter": ("nozzle_diameter", float),
			
 
				-            "bed_temperature": ("bed_temperature", int),
			
 
				-            "nozzle_temperature": ("nozzle_temperature", int),
			
 
				-        }
			
 
				-
			
 
				-        for key, (search_key, converter) in settings_map.items():
			
 
				-            if key not in self.metadata:
			
 
				-                try:
			
 
				-                    # Try JSON format
			
 
				-                    if f'"{search_key}"' in content:
			
 
				-                        start = content.find(f'"{search_key}"')
			
 
				-                        value_start = content.find(":", start) + 1
			
 
				-                        value_end = content.find(",", value_start)
			
 
				-                        if value_end == -1:
			
 
				-                            value_end = content.find("}", value_start)
			
 
				-                        value = content[value_start:value_end].strip().strip('"')
			
 
				-                        self.metadata[key] = converter(value)
			
 
				-                except (ValueError, TypeError):
			
 
				-                    pass  # Skip settings with unconvertible values
			
 
				-
			
 
				     def _parse_3dmodel(self, zf: zipfile.ZipFile):
			
 
				         """Parse 3D/3dmodel.model for MakerWorld metadata."""
			
 
				         try:
			
@@ -602,6 +638,26 @@ class ThreeMFParser:
 
				                 break
			
 
				 
			
 
				 
			
 
				+def extract_printable_objects_from_archive(
			
 
				+    file_path: Path, plate_number: int | None = None
			
 
				+) -> tuple[dict[int, dict], list | None]:
			
 
				+    """Objects and plate bbox for an archived print, read off local disk.
			
 
				+
			
 
				+    The archive of a running print usually holds the very 3MF the printer is
			
 
				+    executing, so the object list can be rebuilt without asking the printer for
			
 
				+    a file we already have -- 15 MB over FTPS from a machine that is mid-print,
			
 
				+    in the case this was written for. Returns empty when the archive has
			
 
				+    no readable 3MF, which is the caller's signal to fall back to the printer.
			
 
				+    """
			
 
				+    if not file_path.is_file() or not str(file_path).endswith(".3mf"):
			
 
				+        return {}, None
			
 
				+    try:
			
 
				+        data = file_path.read_bytes()
			
 
				+    except OSError:
			
 
				+        return {}, None
			
 
				+    return extract_printable_objects_from_3mf(data, plate_number=plate_number, include_positions=True)
			
 
				+
			
 
				+
			
 
				 def extract_printable_objects_from_3mf(
			
 
				     data: bytes, plate_number: int | None = None, include_positions: bool = False
			
 
				 ) -> dict[int, str] | dict[int, dict] | tuple[dict[int, dict], list | None]:
			
@@ -1148,6 +1204,7 @@ class ArchiveService:
 
				         library_file_id: int | None = None,
			
 
				         slicer_ams_mapping: list[int] | None = None,
			
 
				         slicer_ams_mapping_printer_id: int | None = None,
			
 
				+        update_archive_id: int | None = None,
			
 
				     ) -> PrintArchive | None:
			
 
				         """Archive a 3MF file with metadata.
			
 
				 
			
@@ -1185,6 +1242,17 @@ class ArchiveService:
 
				                 reused later on any printer, including the same one (there'd be no way to
			
 
				                 tell). A model-based VP with no fixed target printer has no valid value to
			
 
				                 pass here and must leave both params unset.
			
 
				+            update_archive_id: Fill in an existing archive row instead of adding one.
			
 
				+                Used to upgrade a no-3MF fallback archive once the file finally arrives
			
 
				+                (#2957). Everything above the row itself — the copy, the parse, the
			
 
				+                thumbnail, the cost — is exactly what a fresh archive does; only the
			
 
				+                destination differs. The row must keep its id: the energy-start reading,
			
 
				+                the timelapse session, ``_active_prints``, the start notification and any
			
 
				+                queue link were all written against it while the print was running, and a
			
 
				+                second row would orphan every one of them. Fields the fallback path
			
 
				+                already established from MQTT (``started_at``, ``subtask_id``,
			
 
				+                ``created_by_id``, ``project_id``) are left alone; the 3MF has nothing
			
 
				+                better to say about them.
			
 
				         """
			
 
				         # Verify printer exists if specified
			
 
				         if printer_id is not None:
			
@@ -1325,6 +1393,71 @@ class ArchiveService:
 
				             quantity = len(printable_objects)
			
 
				             logger.debug("Auto-detected %s parts from 3MF printable objects", quantity)
			
 
				 
			
 
				+        # Recovery of an existing fallback row: assign the freshly-parsed values
			
 
				+        # onto it rather than adding a second archive for the same print (#2957).
			
 
				+        if update_archive_id is not None:
			
 
				+            existing = await self.db.get(PrintArchive, update_archive_id)
			
 
				+            if existing is None:
			
 
				+                logger.warning("archive_print: archive %s to update no longer exists", update_archive_id)
			
 
				+                return None
			
 
				+            # `metadata` is freshly parsed from the 3MF, so assigning it drops
			
 
				+            # the row's `no_3mf_available` / `no_3mf_reason` markers as a side
			
 
				+            # effect — which is correct, the archive is no longer a fallback,
			
 
				+            # and it is what stops the Archives banner counting it.
			
 
				+            # `_print_data` is diagnostic history rather than something the 3MF
			
 
				+            # knows about: keep the row's copy for a caller that passed no
			
 
				+            # print_data of its own.
			
 
				+            merged = dict(metadata)
			
 
				+            preserved = (existing.extra_data or {}).get("_print_data")
			
 
				+            if preserved is not None and "_print_data" not in merged:
			
 
				+                merged["_print_data"] = preserved
			
 
				+            # A record that this row started life without a 3MF, which the
			
 
				+            # dropped markers no longer say.
			
 
				+            merged["recovered_no_3mf"] = True
			
 
				+            existing.filename = original_filename or source_file.name
			
 
				+            existing.file_path = str(dest_file.relative_to(settings.base_dir))
			
 
				+            existing.file_size = dest_file.stat().st_size
			
 
				+            existing.content_hash = content_hash
			
 
				+            existing.thumbnail_path = thumbnail_path
			
 
				+            existing.print_name = (
			
 
				+                clean_display_name(display_stem)
			
 
				+                if prefer_filename_for_name
			
 
				+                else (clean_display_name(metadata.get("print_name")) or clean_display_name(display_stem))
			
 
				+            )
			
 
				+            # Only overwrite what the 3MF actually knows. A fallback archive
			
 
				+            # recovered mid-print has a real print_time_seconds from MQTT and a
			
 
				+            # filament type/colour from the AMS; a 3MF that omits a field must
			
 
				+            # not blank them back out.
			
 
				+            for field in (
			
 
				+                "print_time_seconds",
			
 
				+                "filament_used_grams",
			
 
				+                "filament_type",
			
 
				+                "filament_color",
			
 
				+                "layer_height",
			
 
				+                "total_layers",
			
 
				+                "nozzle_diameter",
			
 
				+                "bed_temperature",
			
 
				+                "bed_type",
			
 
				+                "nozzle_temperature",
			
 
				+                "sliced_for_model",
			
 
				+                "makerworld_url",
			
 
				+                "designer",
			
 
				+            ):
			
 
				+                value = metadata.get(field)
			
 
				+                if value is not None:
			
 
				+                    setattr(existing, field, value)
			
 
				+            if cost is not None:
			
 
				+                existing.cost = cost
			
 
				+            existing.quantity = quantity
			
 
				+            existing.extra_data = merged
			
 
				+            if plate_id is not None:
			
 
				+                existing.plate_id = plate_id
			
 
				+            if library_file_id is not None:
			
 
				+                existing.library_file_id = library_file_id
			
 
				+            await self.db.commit()
			
 
				+            await self.db.refresh(existing)
			
 
				+            return existing
			
 
				+
			
 
				         # Create archive record
			
 
				         archive = PrintArchive(
			
 
				             printer_id=printer_id,
			
@@ -1476,52 +1609,140 @@ class ArchiveService:
 
				             # the first soft-delete pass so there is nothing left on disk.
			
 
				             return True
			
 
				 
			
 
				-        dir_to_delete = self._resolve_archive_dir_for_delete(archive)
			
 
				+        dirs_to_delete = self._resolve_archive_dirs_for_delete(archive)
			
 
				+        recorded_paths = (archive.timelapse_path, archive.thumbnail_path)
			
 
				 
			
 
				         await _null_print_log_thumbnail_paths(self.db, archive_id)
			
 
				         await _delete_related_queue_items(self.db, archive_id)
			
 
				         archive.deleted_at = datetime.now(timezone.utc)
			
 
				         await self.db.commit()
			
 
				 
			
 
				-        if dir_to_delete:
			
 
				-            shutil.rmtree(dir_to_delete, ignore_errors=True)
			
 
				+        for directory in dirs_to_delete:
			
 
				+            shutil.rmtree(directory, ignore_errors=True)
			
 
				+        self._purge_id_named_dir(archive_id, recorded_paths)
			
 
				         return True
			
 
				 
			
 
				-    def _resolve_archive_dir_for_delete(self, archive: PrintArchive) -> Path | None:
			
 
				-        """Return the on-disk directory that backs *archive*, after the same
			
 
				-        two safety checks ``delete_archive`` enforces.
			
 
				+    def _resolve_archive_dirs_for_delete(self, archive: PrintArchive) -> list[Path]:
			
 
				+        """Directories belonging to *archive* alone, safe to remove whole.
			
 
				+
			
 
				+        Shared by soft-delete and hard-delete so the two cannot drift apart
			
 
				+        again — the previous helper said it was extracted for that reason, and
			
 
				+        ``delete_archive`` was still doing its own copy of the same rules.
			
 
				+
			
 
				+        An archive with a 3MF owns the directory its ``file_path`` sits in,
			
 
				+        ``<archive_dir>/<printer_id>/<timestamp>_<name>/``. Any archive may also
			
 
				+        own ``archive/no_source/<id>/``, where a source 3MF uploaded onto a
			
 
				+        no-3MF archive lands (#1531); that one was never removed, so deleting
			
 
				+        such an archive freed the row and left the upload behind.
			
 
				+
			
 
				+        Two directories are deliberately absent. ``<base_dir>/photos`` is the
			
 
				+        legacy location *every* no-3MF archive wrote into at once, so removing
			
 
				+        it on one delete would take the others' photos with it. And
			
 
				+        ``<archive_dir>/<id>`` — the directory :func:`resolve_archive_dir` gives
			
 
				+        an archive with no ``file_path`` — is handled by
			
 
				+        :meth:`_purge_id_named_dir` instead, for the reason given there.
			
 
				+        """
			
 
				+        candidates: list[Path] = []
			
 
				+        # Only when there is a path to derive it from. Without one,
			
 
				+        # ``resolve_archive_dir`` returns the id-named directory, which must not
			
 
				+        # be removed wholesale -- see _purge_id_named_dir.
			
 
				+        if archive.file_path and archive.file_path.strip():
			
 
				+            candidates.append(resolve_archive_dir(archive))
			
 
				+        candidates.append(settings.archive_dir / "no_source" / str(archive.id))
			
 
				 
			
 
				-        Extracted so soft-delete and hard-delete share the path-resolution
			
 
				-        rules. Returns ``None`` when nothing should be removed from disk
			
 
				-        (no file_path, path outside archive_dir, or path not deep enough).
			
 
				+        resolved: list[Path] = []
			
 
				+        for candidate in candidates:
			
 
				+            if candidate in resolved or not candidate.is_dir():
			
 
				+                continue
			
 
				+            try:
			
 
				+                relative_path = candidate.resolve().relative_to(settings.archive_dir.resolve())
			
 
				+            except ValueError:
			
 
				+                # A genuine guard trip, unlike the empty ``file_path`` this used
			
 
				+                # to shout about: the row points somewhere outside the archive
			
 
				+                # tree, which only a corrupted import or hand-edited SQL can do.
			
 
				+                logger.error(
			
 
				+                    f"SECURITY: Refusing to delete archive {archive.id} - "
			
 
				+                    f"path {candidate} is outside archive directory {settings.archive_dir}"
			
 
				+                )
			
 
				+                continue
			
 
				+            # Two deep, not one. An archive directory has been
			
 
				+            # ``<archive_dir>/<printer_id>/<timestamp>_<name>/`` since the first
			
 
				+            # commit, so nothing legitimate sits one level down -- but the
			
 
				+            # per-printer folder does, and it holds every print that printer
			
 
				+            # ever made. Under the old ``< 1`` a row whose file_path had lost a
			
 
				+            # path component took the whole folder with it.
			
 
				+            if len(relative_path.parts) < 2:
			
 
				+                logger.error(
			
 
				+                    f"SECURITY: Refusing to delete archive {archive.id} - "
			
 
				+                    f"path {candidate} is not deep enough inside archive directory"
			
 
				+                )
			
 
				+                continue
			
 
				+            resolved.append(candidate)
			
 
				+        return resolved
			
 
				+
			
 
				+    def _purge_id_named_dir(self, archive_id: int, recorded_paths: tuple[str | None, ...]) -> None:
			
 
				+        """Remove one archive's own files from ``<archive_dir>/<id>``, carefully.
			
 
				+
			
 
				+        Takes the recorded paths rather than the row because ``delete_archive``
			
 
				+        removes the row before it touches the disk, deliberately: a failed
			
 
				+        commit must leave the files alone. Reading ``archive.timelapse_path``
			
 
				+        off a deleted instance afterwards would raise or silently refresh.
			
 
				+
			
 
				+        That directory is where an archive with no 3MF keeps its timelapse and
			
 
				+        its finish photos (:func:`resolve_archive_dir`). It is emphatically NOT
			
 
				+        an ``rmtree`` target, because it shares a namespace with the per-printer
			
 
				+        folders: a normal archive lives at
			
 
				+        ``<archive_dir>/<printer_id>/<timestamp>_<name>/``, so ``archive/1`` is
			
 
				+        printer 1's folder *and* the directory the helper hands archive id 1.
			
 
				+        Archive ids and printer ids are both small integers from unrelated
			
 
				+        sequences, so on any install the first few archives collide with the
			
 
				+        printers. Removing the directory would take every print that printer
			
 
				+        ever made — measured on a scratch tree before this guard existed.
			
 
				+
			
 
				+        So nothing is removed that has not been identified as this archive's.
			
 
				+        ``photos`` is a fixed subdirectory name and an archive directory is
			
 
				+        always ``<timestamp>_<name>``, so the two cannot be confused; the video
			
 
				+        is removed by the path the row itself records. The directory then goes
			
 
				+        only if that left it empty, which a printer folder holding prints never
			
 
				+        will. Anything unrecognised keeps it alive and is leaked rather than
			
 
				+        guessed at — the safe direction for a recursive delete.
			
 
				         """
			
 
				-        if not archive.file_path or not archive.file_path.strip():
			
 
				-            logger.error(
			
 
				-                f"SECURITY: Refusing to delete files for archive {archive.id} - "
			
 
				-                f"file_path is empty or invalid: '{archive.file_path}'"
			
 
				-            )
			
 
				-            return None
			
 
				+        directory = settings.archive_dir / str(archive_id)
			
 
				+        if not directory.is_dir():
			
 
				+            return
			
 
				+        try:
			
 
				+            relative_path = directory.resolve().relative_to(settings.archive_dir.resolve())
			
 
				+        except ValueError:
			
 
				+            return
			
 
				+        if len(relative_path.parts) != 1:
			
 
				+            return
			
 
				 
			
 
				-        file_path = settings.base_dir / archive.file_path
			
 
				-        if not file_path.exists():
			
 
				-            return None
			
 
				+        shutil.rmtree(directory / "photos", ignore_errors=True)  # SEC-PATH-OK: constant subdirectory
			
 
				+        for recorded in recorded_paths:
			
 
				+            if not recorded:
			
 
				+                continue
			
 
				+            try:
			
 
				+                # Two checks, not one. safe_join_under rejects the absolute and
			
 
				+                # ``..`` shapes and proves the result is inside the data
			
 
				+                # directory; assert_under then narrows it to *this* archive's
			
 
				+                # own directory, because a row whose timelapse_path names
			
 
				+                # another archive's file must not take it with this delete.
			
 
				+                # The column is written by Bambuddy from a filename the printer
			
 
				+                # supplied over FTP, so it is not a trusted constant.
			
 
				+                candidate = safe_join_under(settings.base_dir, recorded, http=False)
			
 
				+                assert_under(directory, candidate, http=False)
			
 
				+            except PathTraversalError:
			
 
				+                continue
			
 
				+            if candidate.is_file():
			
 
				+                candidate.unlink(missing_ok=True)
			
 
				 
			
 
				-        archive_dir = file_path.parent
			
 
				         try:
			
 
				-            relative_path = archive_dir.resolve().relative_to(settings.archive_dir.resolve())
			
 
				-        except ValueError:
			
 
				-            logger.error(
			
 
				-                f"SECURITY: Refusing to delete archive {archive.id} - "
			
 
				-                f"path {archive_dir} is outside archive directory {settings.archive_dir}"
			
 
				-            )
			
 
				-            return None
			
 
				-        if len(relative_path.parts) < 1:
			
 
				-            logger.error(
			
 
				-                f"SECURITY: Refusing to delete archive {archive.id} - "
			
 
				-                f"path {archive_dir} is not deep enough inside archive directory"
			
 
				-            )
			
 
				-            return None
			
 
				-        return archive_dir
			
 
				+            directory.rmdir()
			
 
				+        except OSError:
			
 
				+            # Not empty (a printer folder, or a file this archive did not
			
 
				+            # record) or already gone. Both are fine: the point of rmdir over
			
 
				+            # rmtree is that it cannot take anything with it.
			
 
				+            pass
			
 
				 
			
 
				     async def delete_archive(self, archive_id: int) -> bool:
			
 
				         """Delete an archive and its files."""
			
@@ -1529,46 +1750,12 @@ class ArchiveService:
 
				         if not archive:
			
 
				             return False
			
 
				 
			
 
				-        # Resolve the directory to delete BEFORE committing the DB change
			
 
				-        dir_to_delete: Path | None = None
			
 
				-
			
 
				-        if archive.file_path and archive.file_path.strip():
			
 
				-            file_path = settings.base_dir / archive.file_path
			
 
				-            if file_path.exists():
			
 
				-                archive_dir = file_path.parent
			
 
				-
			
 
				-                # Safety check 1: archive_dir must be inside archive_dir
			
 
				-                try:
			
 
				-                    archive_dir.resolve().relative_to(settings.archive_dir.resolve())
			
 
				-                except ValueError:
			
 
				-                    logger.error(
			
 
				-                        f"SECURITY: Refusing to delete archive {archive_id} - "
			
 
				-                        f"path {archive_dir} is outside archive directory {settings.archive_dir}"
			
 
				-                    )
			
 
				-                    await self.db.delete(archive)
			
 
				-                    await self.db.commit()
			
 
				-                    return True
			
 
				-
			
 
				-                # Safety check 2: archive_dir must be at least 1 level deep inside archive_dir
			
 
				-                try:
			
 
				-                    relative_path = archive_dir.resolve().relative_to(settings.archive_dir.resolve())
			
 
				-                    if len(relative_path.parts) < 1:
			
 
				-                        logger.error(
			
 
				-                            f"SECURITY: Refusing to delete archive {archive_id} - "
			
 
				-                            f"path {archive_dir} is not deep enough inside archive directory"
			
 
				-                        )
			
 
				-                        await self.db.delete(archive)
			
 
				-                        await self.db.commit()
			
 
				-                        return True
			
 
				-                except ValueError:
			
 
				-                    pass  # Already handled above
			
 
				-
			
 
				-                dir_to_delete = archive_dir
			
 
				-        else:
			
 
				-            logger.error(
			
 
				-                f"SECURITY: Refusing to delete files for archive {archive_id} - "
			
 
				-                f"file_path is empty or invalid: '{archive.file_path}'"
			
 
				-            )
			
 
				+        # Resolved BEFORE committing the DB change, since the row is what says
			
 
				+        # where the files are. Shared with soft-delete rather than repeated
			
 
				+        # here: this was a second copy of the same checks and it had already
			
 
				+        # diverged from the one it was extracted from.
			
 
				+        dirs_to_delete = self._resolve_archive_dirs_for_delete(archive)
			
 
				+        recorded_paths = (archive.timelapse_path, archive.thumbnail_path)
			
 
				 
			
 
				         # NULL stale thumbnail_path on linked PrintLogEntries before the FK
			
 
				         # SET-NULL cascade fires. The on-disk file is about to be removed by
			
@@ -1583,8 +1770,9 @@ class ArchiveService:
 
				         await self.db.commit()
			
 
				 
			
 
				         # Only delete files AFTER the DB commit succeeds to avoid orphaned records
			
 
				-        if dir_to_delete:
			
 
				-            shutil.rmtree(dir_to_delete, ignore_errors=True)
			
 
				+        for directory in dirs_to_delete:
			
 
				+            shutil.rmtree(directory, ignore_errors=True)
			
 
				+        self._purge_id_named_dir(archive_id, recorded_paths)
			
 
				 
			
 
				         return True
			
 
				 
			
@@ -1605,11 +1793,17 @@ class ArchiveService:
 
				         if not archive:
			
 
				             return False
			
 
				 
			
 
				-        # Get archive directory
			
 
				-        file_path = (
			
 
				-            settings.base_dir / archive.file_path
			
 
				-        )  # SEC-PATH-OK: archive.file_path is DB-stored, set by archive_print() under settings.archive_dir
			
 
				-        archive_dir = file_path.parent
			
 
				+        # Where this archive's files live. Deliberately the shared helper: an
			
 
				+        # archive created without a 3MF has ``file_path == ""``, and deriving the
			
 
				+        # directory here as ``(base_dir / "").parent`` resolved to the parent of
			
 
				+        # base_dir — outside the data directory entirely. In Docker that is /app,
			
 
				+        # so the write failed with EACCES and the timelapse was retried and
			
 
				+        # discarded 25 times; where the parent happens to be writable it
			
 
				+        # succeeded, dropped a stray video next to the install, and then failed
			
 
				+        # anyway on the relative_to() below. Every H2-series and P2S print sent
			
 
				+        # from the slicer takes that path, because the file goes to internal
			
 
				+        # storage and no 3MF can be fetched.
			
 
				+        archive_dir = resolve_archive_dir(archive)
			
 
				 
			
 
				         # Save timelapse - use thread pool to avoid blocking event loop
			
 
				         # (timelapse files can be 100MB+, sync write blocks for seconds).
			
@@ -1629,6 +1823,10 @@ class ArchiveService:
 
				                 archive_id,
			
 
				             )
			
 
				             return False
			
 
				+        # Created only once the name has been vetted, so a rejected filename
			
 
				+        # leaves nothing behind. A no-3MF archive has never had a directory of
			
 
				+        # its own, and the timelapse can be the first thing to want one.
			
 
				+        await asyncio.to_thread(lambda: timelapse_file.parent.mkdir(parents=True, exist_ok=True))
			
 
				         await asyncio.to_thread(timelapse_file.write_bytes, timelapse_data)
			
 
				 
			
 
				         # Update archive record
			
@@ -1712,7 +1910,7 @@ async def _convert_timelapse_to_mp4(archive_id: int, source_path: Path) -> None:
 
				             logger.warning(
			
 
				                 "Timelapse conversion failed for archive %s: %s",
			
 
				                 archive_id,
			
 
				-                stderr.decode()[-500:],
			
 
				+                summarize_ffmpeg_stderr(stderr) or NO_FFMPEG_OUTPUT,
			
 
				             )
			
 
				             if mp4_path.exists():
			
 
				                 mp4_path.unlink()
			
--- a/backend/app/services/bambu_ftp.py
+++ b/backend/app/services/bambu_ftp.py
--- a/backend/app/services/bambu_mqtt.py
+++ b/backend/app/services/bambu_mqtt.py
@@ -22,6 +22,8 @@ from datetime import datetime, timezone
 
				 import paho.mqtt.client as mqtt
			
 
				 
			
 
				 from backend.app.services.hms_actions import HMSAction, get_actions_for_error_code
			
 
				+from backend.app.services.hms_errors import describe_fault
			
 
				+from backend.app.utils.ams_drying import ACTIVE_DRY_STATUSES
			
 
				 
			
 
				 logger = logging.getLogger(__name__)
			
 
				 
			
@@ -40,12 +42,6 @@ _AMS_MODULE_PREFIXES = ("ams/", "n3f/", "n3s/")
 
				 # printer_manager.ACTIVE_PRINT_STATES and print_scheduler._ACTIVE_PRINT_STATES.
			
 
				 _ACTIVE_PRINT_STATES = frozenset({"PREPARE", "SLICING", "RUNNING", "PAUSE"})
			
 
				 
			
 
				-# AMS dry_status phases (info bits 4-7) in which a drying cycle is still live, so
			
 
				-# a dry_time of 0 alongside one of them is a transient rather than a completion
			
 
				-# (#2759). 0=Off, 4=Stopping and 5=Error all mean the cycle is over or ending and
			
 
				-# are deliberately excluded — those SHOULD end it.
			
 
				-_ACTIVE_DRY_STATUSES = frozenset({1, 2, 3})  # Checking, Drying, Cooling
			
 
				-
			
 
				 # A drying cycle that runs to term ends with its countdown all but exhausted, so
			
 
				 # the last dry_time we saw before the drop to 0 tells us whether the firmware
			
 
				 # ended the cycle on schedule or aborted it. More than this many minutes still on
			
@@ -115,6 +111,34 @@ def normalize_am_unit_id(ams_id: int) -> int:
 
				     return A2L_LITE_NORMALIZED_AMS_ID if ams_id == A2L_LITE_PHYSICAL_AMS_ID else ams_id
			
 
				 
			
 
				 
			
 
				+def wire_tray_color(tray_color: str | None) -> str:
			
 
				+    """Normalise a colour to the form AMS firmware actually parses: UPPERCASE hex.
			
 
				+
			
 
				+    P1S firmware 01.10.00.00 parses every lowercase hex letter in ``tray_color``
			
 
				+    as a zero, and does it silently: the command response echoes the value you
			
 
				+    sent and reports ``result: "success"``, so only the next AMS push shows what
			
 
				+    was really stored. Measured on the reporter's machine (#2987), where the
			
 
				+    spool's own ``rgba`` is stored lowercase and went out verbatim:
			
 
				+
			
 
				+        sent 09ff00ff  ->  AMS reports 09000000
			
 
				+        sent ff5100ff  ->  AMS reports 00510000
			
 
				+        sent 090000FF  ->  AMS reports 090000FF
			
 
				+
			
 
				+    A mangled colour is not merely cosmetic. The auto-unlink sweep compares the
			
 
				+    tray against the spool it is assigned to, so the tray Bambuddy just wrote no
			
 
				+    longer matches the spool that asked for it and the assignment is deleted
			
 
				+    seconds after being made -- and re-assigning through the slot modal writes
			
 
				+    the mangled colour back, because the modal seeds itself from the tray.
			
 
				+
			
 
				+    Applied here, at the one place the command is built, rather than in each of
			
 
				+    the four callers: a caller that forgets is exactly how this arrived.
			
 
				+
			
 
				+    A leading ``#`` is stripped -- the wire format carries bare hex -- and a
			
 
				+    blank stays blank, which is how a slot is cleared.
			
 
				+    """
			
 
				+    return (tray_color or "").strip().lstrip("#").upper()
			
 
				+
			
 
				+
			
 
				 def a2l_lite_wire_ids(ams_id: int, tray_id: int) -> tuple[int, int, int] | None:
			
 
				     """Translate a normalised A2L slot back to the physical wire form.
			
 
				 
			
@@ -630,7 +654,13 @@ class HMSError:
 
				     attr: int  # Attribute value for constructing wiki URL
			
 
				     module: int
			
 
				     severity: int  # 1=fatal, 2=serious, 3=common, 4=info
			
 
				-    message: str = ""
			
 
				+    # The bundled catalogue's sentence for this fault, resolved once here so
			
 
				+    # every surface that reports it — the status response, the WebSocket
			
 
				+    # broadcast, the completion payload, notifications — says the same thing.
			
 
				+    # None when the catalogue does not cover the code; `describe_fault` documents
			
 
				+    # the lookup and why the lossy `hms[]` collapse is kept as it was.
			
 
				+    # Replaces a `message` field that was never set or read anywhere.
			
 
				+    description: str | None = None
			
 
				     # User-facing remediation actions from the bundled HMS catalog (e.g. "RESUME_PRINTING",
			
 
				     # "CHECK_ASSISTANT"). Defaults to an empty list rather than None so the field always
			
 
				     # satisfies HMSErrorResponse.actions: list[str] — a future code path that builds an
			
@@ -708,16 +738,74 @@ class FilaSwitchState:
 
				     AMS and the printer's extruders. When installed, the AMS no longer has a
			
 
				     fixed extruder assignment — any slot can be routed to any extruder via the
			
 
				     track switch. Detected from print.device.fila_switch in MQTT.
			
 
				+
			
 
				+    The switch has two inlets (In-A, In-B) and two outlets (Out-A, Out-B), and
			
 
				+    can pair any inlet with any outlet. Which AMS sits on which *inlet* is the
			
 
				+    stable, operator-visible relationship — it is set on the printer's "Manual
			
 
				+    AMS Setup" screen and read back from AMS ``info`` bits 24-27, not from here.
			
 
				+
			
 
				+    Field semantics below are taken from BambuStudio's own parser
			
 
				+    (``DevFilaSwitch::ParseFilaSwitchInfo``), not inferred.
			
 
				     """
			
 
				 
			
 
				     installed: bool = False
			
 
				-    # in[track] = currently loaded slot for that track (-1 = empty). The slot
			
 
				-    # value is reported as observed in MQTT (treated as a global tray ID).
			
 
				+    # Raw ``in`` array, as it arrives. **Index 0 is In-B and index 1 is In-A** —
			
 
				+    # the arrays are ordered B-then-A, which is the opposite of how they read.
			
 
				+    # Each value is snow-encoded: bits 8-15 = AMS id, bits 0-7 = slot. -1 = the
			
 
				+    # inlet is empty. Use `inlet_slot()` rather than indexing this directly.
			
 
				     in_slots: list[int] = field(default_factory=list)
			
 
				-    # out[track] = extruder this track terminates at (0 = right/main, 1 = left)
			
 
				+    # Raw ``out`` array, same B-then-A order. out[i] = the extruder that *outlet*
			
 
				+    # terminates at (0 = right/main, 1 = left/deputy), or 0xE when unset. Note
			
 
				+    # this is the outlet's static wiring, NOT the live inlet→outlet route: which
			
 
				+    # inlet is currently paired with which outlet is not reported at all.
			
 
				     out_extruders: list[int] = field(default_factory=list)
			
 
				-    stat: int = 0  # status flags (0 = idle)
			
 
				-    info: int = 0  # info flags
			
 
				+    stat: int = 0  # CaliStatus: 0 = idle, 1 = calibration stepping
			
 
				+    info: int = 0  # bit 0 = inlet has filament
			
 
				+
			
 
				+    def inlet_slot(self, inlet: str) -> tuple[int, int] | None:
			
 
				+        """Decode ``in`` for inlet ``"A"`` or ``"B"`` into ``(ams_id, slot)``.
			
 
				+
			
 
				+        Returns None when the inlet is empty, unreported, or ``inlet`` is not
			
 
				+        one of A/B.
			
 
				+        """
			
 
				+        index = {"A": 1, "B": 0}.get(inlet.upper())
			
 
				+        if index is None or index >= len(self.in_slots):
			
 
				+            return None
			
 
				+        raw = self.in_slots[index]
			
 
				+        if raw < 0:
			
 
				+            return None
			
 
				+        return (raw >> 8) & 0xFF, raw & 0xFF
			
 
				+
			
 
				+
			
 
				+# ``snow``/``spre``/``star`` all use this sentinel for "nothing here". Studio
			
 
				+# only special-cases it on single-extruder machines, but 0xFFFF decodes to AMS
			
 
				+# 255 slot 255 and slot 255 is not a real slot on any machine, so treating it
			
 
				+# as empty everywhere is strictly safer than reading it as the external spool.
			
 
				+_EXTRUDER_SLOT_EMPTY = 0xFFFF
			
 
				+
			
 
				+
			
 
				+@dataclass
			
 
				+class ExtruderSlot:
			
 
				+    """Which AMS slot an extruder is currently fed from.
			
 
				+
			
 
				+    Parsed from ``print.device.extruder.info[i]`` — ``snow`` is snow-encoded
			
 
				+    exactly like ``fila_switch.in`` (bits 8-15 = AMS id, bits 0-7 = slot), and
			
 
				+    bit 1 of ``info`` says whether the extruder actually holds filament. Field
			
 
				+    semantics from BambuStudio's ``DevExtruderSystem::ParseExtruderInfo``.
			
 
				+
			
 
				+    ``state.tray_now`` cannot answer this: it is a single value for the whole
			
 
				+    printer, so on a dual-nozzle machine with both hotends loaded it names only
			
 
				+    one of them. Unloading a specific slot needs to know which extruder is
			
 
				+    holding it, which is what this is for.
			
 
				+    """
			
 
				+
			
 
				+    ams_id: int | None = None
			
 
				+    slot_id: int | None = None
			
 
				+    has_filament: bool = False
			
 
				+
			
 
				+    def holds(self, ams_id: int, slot_id: int) -> bool:
			
 
				+        """True when this extruder is fed from exactly ``(ams_id, slot_id)``."""
			
 
				+        return self.ams_id == ams_id and self.slot_id == slot_id
			
 
				 
			
 
				 
			
 
				 @dataclass
			
@@ -793,7 +881,12 @@ class PrinterState:
 
				     wifi_signal: int | None = None  # WiFi signal strength in dBm
			
 
				     wired_network: bool = False  # Ethernet connection detected (home_flag bit 18)
			
 
				     door_open: bool = False  # Enclosure door open (home_flag bit 23; models with a door sensor: X1/X1C/X1E/X2D/P2S/H2*)
			
 
				-    # Nozzle hardware info (for dual nozzle printers, index 0 = left, 1 = right)
			
 
				+    # Nozzle hardware info. Indexed by EXTRUDER id: [0] is the RIGHT hotend and
			
 
				+    # [1] the left, measured 2026-08-27 on an H2D fitted with 0.4 left / 0.6
			
 
				+    # right. (The legacy parser below writes left -> [0], but it only ever runs
			
 
				+    # for single-nozzle printers -- every dual-nozzle model reports
			
 
				+    # device.nozzle.info instead.) Read it through services.slot_nozzle rather
			
 
				+    # than indexing it directly.
			
 
				     nozzles: list = field(default_factory=lambda: [NozzleInfo(), NozzleInfo()])
			
 
				     # AI detection and print options
			
 
				     print_options: PrintOptions = field(default_factory=PrintOptions)
			
@@ -839,6 +932,16 @@ class PrinterState:
 
				     # Filament Track Switch (FTS) accessory — when installed, AMS info reports
			
 
				     # bits 8-11 = 0xE (uninitialized) because routing is dynamic. See #1162.
			
 
				     fila_switch: "FilaSwitchState" = field(default_factory=lambda: FilaSwitchState())
			
 
				+    # Per-AMS FTS inlet binding: {ams_id: "A" | "B"}. Which of the switch's two
			
 
				+    # filament inlets an AMS is plumbed into, as set on the printer's "Manual AMS
			
 
				+    # Setup" screen. Only populated when an FTS is installed — without one an AMS
			
 
				+    # is bound to an extruder instead and this stays empty. See FilaSwitchState.
			
 
				+    ams_switch_inlet: dict = field(default_factory=dict)
			
 
				+    # Which AMS slot each extruder is fed from: {extruder_id: ExtruderSlot}.
			
 
				+    # Only populated by printers that report ``device.extruder.info`` (H2/X2
			
 
				+    # series). Empty elsewhere, which every reader has to tolerate — see
			
 
				+    # ExtruderSlot for why tray_now cannot stand in for it.
			
 
				+    extruder_slots: dict = field(default_factory=dict)
			
 
				     # Plate dispatched by Bambuddy for the current print. Some firmware versions
			
 
				     # (P1S 01.10.00.00) only put the .3mf filename in print.gcode_file, so the
			
 
				     # regex used to derive the plate number from the path always falls back to
			
@@ -1051,6 +1154,17 @@ class BambuMQTTClient:
 
				     # Class-level cache: serial_number -> False when request topic is known unsupported.
			
 
				     # Persists across client instances so reconnects don't re-trigger failed subscriptions.
			
 
				     _request_topic_cache: dict[str, bool] = {}
			
 
				+    # serial_number -> consecutive disconnects seen shortly after subscribing to
			
 
				+    # the request topic. A SUBACK failure is the broker answering the question;
			
 
				+    # a disconnect is only circumstantial, and any drop inside the window looks
			
 
				+    # identical -- a network blip, the printer rebooting, the container being
			
 
				+    # stopped mid-probe. Latching on the first one costs ams_mapping capture for
			
 
				+    # the rest of the process on a printer that supports it perfectly well
			
 
				+    # (#2953). Require the drop to repeat before believing it; a printer that
			
 
				+    # really does refuse the topic answers the same way every time and pays one
			
 
				+    # extra reconnect for it.
			
 
				+    _request_topic_probe_failures: dict[str, int] = {}
			
 
				+    _REQUEST_TOPIC_PROBE_LIMIT: int = 2
			
 
				     # Counter for generating unique MQTT client IDs across instances.
			
 
				     _client_instance_counter: int = 0
			
 
				 
			
@@ -1078,6 +1192,7 @@ class BambuMQTTClient:
 
				         on_finish_photo_moment: Callable[[dict], None] | None = None,
			
 
				         on_assignment_verified: Callable[[int, int, bool, dict], None] | None = None,
			
 
				         on_tray_change: Callable[[int, int], None] | None = None,
			
 
				+        on_fts_inlet_change: Callable[[int, str], None] | None = None,
			
 
				     ):
			
 
				         self.ip_address = ip_address
			
 
				         self.serial_number = serial_number
			
@@ -1089,6 +1204,9 @@ class BambuMQTTClient:
 
				         self.on_print_start = on_print_start
			
 
				         self.on_print_complete = on_print_complete
			
 
				         self.on_ams_change = on_ams_change
			
 
				+        # Fired when an AMS is moved to the switch's other inlet, which changes
			
 
				+        # the nozzle it feeds and so invalidates its slots' K-profile bindings.
			
 
				+        self.on_fts_inlet_change = on_fts_inlet_change
			
 
				         self.on_layer_change = on_layer_change
			
 
				         # #2547: fired when `mc_percent` advances during a running print.
			
 
				         # `on_layer_change` stops firing the instant the final layer starts, so
			
@@ -1230,12 +1348,35 @@ class BambuMQTTClient:
 
				         # Value: {"nozzle": str, "event": asyncio.Event, "profiles": list | None}.
			
 
				         self._sequence_id: int = 0
			
 
				         self._pending_kprofile_requests: dict[str, dict] = {}
			
 
				+        # The printer's calibration table, one bucket per nozzle diameter.
			
 
				+        #
			
 
				+        # An extrusion_cali_get response is the complete table for *one* nozzle
			
 
				+        # size, and the printer answers whoever asks — including BambuStudio,
			
 
				+        # whose queries land on the same report topic we subscribe to. Assigning
			
 
				+        # each response straight to state.kprofiles therefore let any single
			
 
				+        # answer stand for the whole printer: a GitHub backup probing
			
 
				+        # 0.2/0.4/0.6/0.8 in turn finished on 0.8, which holds no profiles on a
			
 
				+        # 0.4+0.6 machine, and left the list empty until something refilled it.
			
 
				+        # Measured on the maintainer's H2 on 2026-08-25, and visible on the AMS
			
 
				+        # card because H2-series trays carry no `k` of their own — the slot's
			
 
				+        # K value is resolved from cali_idx against exactly this list.
			
 
				+        #
			
 
				+        # Keyed by diameter so a response only ever replaces the bucket it
			
 
				+        # actually describes; state.kprofiles is then the union across buckets.
			
 
				+        # An empty answer for a nozzle the printer doesn't have empties that
			
 
				+        # bucket alone.
			
 
				+        self._kprofiles_by_nozzle: dict[str, list] = {}
			
 
				         # Acks for K-profile *writes* (extrusion_cali_set / extrusion_cali_del),
			
 
				         # keyed by the sequence_id we sent. The printer echoes it back, measured
			
 
				         # on both an X1C and an H2D (#2718). Filled by the MQTT thread, drained
			
 
				         # by await_cali_ack.
			
 
				         self._pending_cali_acks: dict[str, dict | None] = {}
			
 
				 
			
 
				+        # Identifies the one project_file *we* dispatched, so its echo on the
			
 
				+        # topic can be told apart from a slicer's. One-shot: consumed by the
			
 
				+        # first frame that matches. See _project_file_key.
			
 
				+        self._own_project_file_key: str | None = None
			
 
				+
			
 
				         # Xcam hold timers - OrcaSlicer pattern: ignore incoming data for 3 seconds after command
			
 
				         # Key: module_name, Value: timestamp when command was sent
			
 
				         self._xcam_hold_start: dict[str, float] = {}
			
@@ -1655,6 +1796,7 @@ class BambuMQTTClient:
 
				                     )
			
 
				                     self._request_topic_confirmed = True
			
 
				                     BambuMQTTClient._request_topic_cache[self.serial_number] = True
			
 
				+                    BambuMQTTClient._request_topic_probe_failures.pop(self.serial_number, None)
			
 
				             self._request_topic_sub_mid = None
			
 
				             self._request_topic_sub_time = 0.0
			
 
				 
			
@@ -1711,13 +1853,30 @@ class BambuMQTTClient:
 
				             self._request_topic_sub_time > 0
			
 
				             and not self._request_topic_confirmed
			
 
				             and time.time() - self._request_topic_sub_time < 10.0
			
 
				+            # A disconnect we asked for says nothing about the subscription.
			
 
				+            and self._disconnection_event is None
			
 
				         ):
			
 
				-            logger.warning(
			
 
				-                "[%s] Disconnected shortly after request topic subscription. Disabling request topic for this printer.",
			
 
				-                self.serial_number,
			
 
				-            )
			
 
				-            self._request_topic_supported = False
			
 
				-            BambuMQTTClient._request_topic_cache[self.serial_number] = False
			
 
				+            failures = BambuMQTTClient._request_topic_probe_failures.get(self.serial_number, 0) + 1
			
 
				+            BambuMQTTClient._request_topic_probe_failures[self.serial_number] = failures
			
 
				+            if failures >= BambuMQTTClient._REQUEST_TOPIC_PROBE_LIMIT:
			
 
				+                logger.warning(
			
 
				+                    "[%s] Disconnected shortly after request topic subscription %d times. "
			
 
				+                    "Disabling request topic for this printer — ams_mapping capture from "
			
 
				+                    "slicer-initiated prints is unavailable, and their filament will be "
			
 
				+                    "attributed from the printer's own tray reporting instead.",
			
 
				+                    self.serial_number,
			
 
				+                    failures,
			
 
				+                )
			
 
				+                self._request_topic_supported = False
			
 
				+                BambuMQTTClient._request_topic_cache[self.serial_number] = False
			
 
				+            else:
			
 
				+                logger.info(
			
 
				+                    "[%s] Disconnected shortly after request topic subscription (%d/%d). "
			
 
				+                    "Retrying it on the next connection before giving up.",
			
 
				+                    self.serial_number,
			
 
				+                    failures,
			
 
				+                    BambuMQTTClient._REQUEST_TOPIC_PROBE_LIMIT,
			
 
				+                )
			
 
				         self._request_topic_sub_mid = None
			
 
				         self._request_topic_sub_time = 0.0
			
 
				 
			
@@ -1826,16 +1985,94 @@ class BambuMQTTClient:
 
				             # Diagnostic for #1162 follow-up (X2D + FTS routing): when a
			
 
				             # slicer-launched project_file passes through the request topic,
			
 
				             # log the full payload so we can diff Studio's field set against
			
 
				-            # ours. We pin our own sequence_id to "20000" (line ~3195), so
			
 
				-            # any other value means the command came from Studio/Orca, not
			
 
				-            # from us.
			
 
				-            if print_data.get("sequence_id") != "20000":
			
 
				+            # ours.
			
 
				+            #
			
 
				+            # This used to read `sequence_id != "20000"`, on the belief that
			
 
				+            # 20000 was ours alone. It is not: 20000 is the slicer convention
			
 
				+            # Bambuddy adopted -- bind_server documents the slicer sending it
			
 
				+            # during detect, and measured on the wire OrcaSlicer dispatched
			
 
				+            # 20000 then 20001 while BambuStudio was on 20009/20010, both
			
 
				+            # counting up from the same base. So the test swallowed whichever
			
 
				+            # slicer dispatch happened to land on 20000, which on a fresh
			
 
				+            # slicer start is the first one. Match our own dispatch instead.
			
 
				+            if self._project_file_key(print_data) == self._own_project_file_key:
			
 
				+                self._own_project_file_key = None
			
 
				+            else:
			
 
				                 logger.info(
			
 
				                     "[%s] External project_file payload: %s",
			
 
				                     self.serial_number,
			
 
				                     json.dumps(print_data),
			
 
				                 )
			
 
				 
			
 
				+    def _capture_report_project_file(self, print_data: dict) -> None:
			
 
				+        """Read a print's destination off a ``project_file`` *response* (#1820).
			
 
				+
			
 
				+        ``_handle_request_message`` only ever sees the request topic, so a print
			
 
				+        started from the printer's own touchscreen -- which publishes nothing --
			
 
				+        left ``current_project_url`` at None, and the storage verdict fell
			
 
				+        through to the ``sdcard`` fallback for the one case it was written for.
			
 
				+        On an H2S that flag is True (its "card" is the internal eMMC), so the
			
 
				+        verdict came back reachable and the ~110-connection sweep ran in full.
			
 
				+
			
 
				+        The printer does announce it: an unsolicited ``project_file`` response
			
 
				+        on the report topic, ~2 s before ``gcode_state`` reaches PREPARE,
			
 
				+        carrying ``file:///userdata/model/history/<name>.gcode.3mf``.
			
 
				+
			
 
				+        This also covers an install nobody had in view: some brokers refuse the
			
 
				+        request-topic subscription, and on those no print of any kind has ever
			
 
				+        populated the field.
			
 
				+
			
 
				+        Both kinds of ``project_file`` on this topic are read -- the printer's
			
 
				+        echo of a dispatch and a screen start -- because both name the
			
 
				+        destination in ``url``, which is the only thing the verdict wants. What
			
 
				+        this must NOT do is reuse ``_handle_request_message``'s "External
			
 
				+        project_file payload" diagnostic: our own dispatch is echoed on *both*
			
 
				+        topics, the request-topic echo arrives first and clears
			
 
				+        ``_own_project_file_key``, so by the time this frame lands the key is
			
 
				+        already None and every Bambuddy-started print would log itself as
			
 
				+        someone else's.
			
 
				+        """
			
 
				+        # Same shape as _handle_request_message: the frame is whatever the
			
 
				+        # printer put on the wire, and this is the first thing to touch it.
			
 
				+        if not isinstance(print_data, dict) or print_data.get("command") != "project_file":
			
 
				+            return
			
 
				+        # A refused dispatch names a file that was never written. Acting on it
			
 
				+        # would pin an archive on a destination nothing ever went to.
			
 
				+        if print_data.get("result") != "SUCCESS":
			
 
				+            return
			
 
				+        url = print_data.get("url")
			
 
				+        if not isinstance(url, str) or not url:
			
 
				+            return
			
 
				+        if self.state.current_project_url != url:
			
 
				+            logger.info(
			
 
				+                "[%s] Print destination from the report topic: %s",
			
 
				+                self.serial_number,
			
 
				+                url,
			
 
				+            )
			
 
				+        self.state.current_project_url = url
			
 
				+        self.state.last_project_url = url
			
 
				+        # On a screen start this frame is the only place the mapping appears --
			
 
				+        # no slicer ever sent one. Fill a gap only: when the request topic
			
 
				+        # already captured this print's mapping that copy is the slicer's own,
			
 
				+        # and the echo can arrive without the field at all.
			
 
				+        if self._captured_ams_mapping is None and isinstance(print_data.get("ams_mapping"), list):
			
 
				+            self._captured_ams_mapping = print_data["ams_mapping"]
			
 
				+            logger.info(
			
 
				+                "[%s] Captured ams_mapping from print response: %s",
			
 
				+                self.serial_number,
			
 
				+                self._captured_ams_mapping,
			
 
				+            )
			
 
				+
			
 
				+    @staticmethod
			
 
				+    def _project_file_key(print_data: dict) -> str:
			
 
				+        """Identity of a project_file dispatch, for telling ours from a slicer's.
			
 
				+
			
 
				+        Sequence id alone cannot do it -- every slicer counts up from the same
			
 
				+        20000 -- so this also carries the file and its destination, which differ
			
 
				+        between any two real dispatches.
			
 
				+        """
			
 
				+        return "|".join(str(print_data.get(field, "")) for field in ("sequence_id", "file", "url", "subtask_name"))
			
 
				+
			
 
				     def _debug_on_change(self, key: str, value: object, msg: str, *args: object) -> None:
			
 
				         """``logger.debug``, but only when ``value`` differs from the last call for ``key``.
			
 
				 
			
@@ -1937,6 +2174,11 @@ class BambuMQTTClient:
 
				         if "print" in payload:
			
 
				             print_data = payload["print"]
			
 
				 
			
 
				+            # Before anything reads the state: this is where a touchscreen-
			
 
				+            # started print announces where its file lives, and the print-start
			
 
				+            # handler asks ~2 s later (#1820).
			
 
				+            self._capture_report_project_file(print_data)
			
 
				+
			
 
				             # Check if xcam is nested inside print data
			
 
				             if "xcam" in print_data:
			
 
				                 logger.debug("[%s] Found xcam inside print data: %s", self.serial_number, print_data["xcam"])
			
@@ -1986,6 +2228,12 @@ class BambuMQTTClient:
 
				                         self._is_dual_nozzle = True
			
 
				                         logger.info("[%s] Detected dual-nozzle printer from device.extruder.info", self.serial_number)
			
 
				 
			
 
				+            # Must run before _handle_ams_data: the per-AMS inlet binding is read
			
 
				+            # out of the AMS info bits, but only means anything once we know a
			
 
				+            # switch is installed. Parsing them the other way round would lose
			
 
				+            # the binding on every frame where the two arrive together.
			
 
				+            self._parse_fila_switch(print_data)
			
 
				+
			
 
				             # Handle AMS data that comes inside print key
			
 
				             if "ams" in print_data:
			
 
				                 try:
			
@@ -2635,6 +2883,66 @@ class BambuMQTTClient:
 
				                     )
			
 
				                 self._has_a2l_am_unit = True
			
 
				 
			
 
				+    def _parse_fila_switch(self, data: dict) -> None:
			
 
				+        """Read the Filament Track Switch block out of a print payload — #1162.
			
 
				+
			
 
				+        Presence of ``device.fila_switch`` means the accessory is installed. Kept
			
 
				+        separate from the rest of the state update because ``_handle_ams_data``
			
 
				+        needs the answer before it parses the AMS info bits, and that runs first.
			
 
				+        """
			
 
				+        if not isinstance(data.get("device"), dict):
			
 
				+            return
			
 
				+        fs_data = data["device"].get("fila_switch")
			
 
				+        if not isinstance(fs_data, dict):
			
 
				+            return
			
 
				+        in_raw = fs_data.get("in")
			
 
				+        out_raw = fs_data.get("out")
			
 
				+        self.state.fila_switch = FilaSwitchState(
			
 
				+            installed=True,
			
 
				+            in_slots=list(in_raw) if isinstance(in_raw, list) else [],
			
 
				+            out_extruders=list(out_raw) if isinstance(out_raw, list) else [],
			
 
				+            stat=int(fs_data.get("stat", 0) or 0),
			
 
				+            info=int(fs_data.get("info", 0) or 0),
			
 
				+        )
			
 
				+
			
 
				+    def _parse_extruder_slots(self, data: dict) -> None:
			
 
				+        """Read which AMS slot each extruder is fed from — ``device.extruder.info``.
			
 
				+
			
 
				+        Absent on printers that do not report the block, in which case the
			
 
				+        previous answer is kept rather than cleared: a partial payload carrying
			
 
				+        only temperatures must not look like "both hotends are now empty".
			
 
				+        """
			
 
				+        device = data.get("device")
			
 
				+        if not isinstance(device, dict):
			
 
				+            return
			
 
				+        info = device.get("extruder", {}).get("info") if isinstance(device.get("extruder"), dict) else None
			
 
				+        if not isinstance(info, list) or not info:
			
 
				+            return
			
 
				+
			
 
				+        slots: dict[int, ExtruderSlot] = {}
			
 
				+        for entry in info:
			
 
				+            if not isinstance(entry, dict) or "id" not in entry:
			
 
				+                continue
			
 
				+            try:
			
 
				+                ext_id = int(entry["id"])
			
 
				+                snow = int(entry.get("snow", _EXTRUDER_SLOT_EMPTY))
			
 
				+                flags = int(entry.get("info", 0) or 0)
			
 
				+            except (TypeError, ValueError):
			
 
				+                continue
			
 
				+            if snow == _EXTRUDER_SLOT_EMPTY or snow < 0:
			
 
				+                ams_id = slot_id = None
			
 
				+            else:
			
 
				+                ams_id = (snow >> 8) & 0xFF
			
 
				+                slot_id = snow & 0xFF
			
 
				+            slots[ext_id] = ExtruderSlot(
			
 
				+                ams_id=ams_id,
			
 
				+                slot_id=slot_id,
			
 
				+                has_filament=bool(flags & 0b10),
			
 
				+            )
			
 
				+
			
 
				+        if slots:
			
 
				+            self.state.extruder_slots = slots
			
 
				+
			
 
				     def _handle_ams_data(self, ams_data):
			
 
				         """Handle AMS data changes for Spoolman integration.
			
 
				 
			
@@ -3143,13 +3451,25 @@ class BambuMQTTClient:
 
				         # BambuStudio DevFilaSystem.cpp parses info as hex string:
			
 
				         #   type_id    = get_flag_bits(info, 0, 4)   // bits 0-3: AMS type
			
 
				         #   extruder_id = get_flag_bits(info, 8, 4)  // bits 8-11: extruder assignment
			
 
				+        #   bind_switch_in = get_flag_bits(info, 24, 4)  // bits 24-27: FTS inlet
			
 
				         # where get_flag_bits uses std::stoull(str, nullptr, 16) — hex parsing.
			
 
				-        # extruder_id: 0=right/main, 1=left/deputy, 0xE=uninitialized (skip)
			
 
				+        # extruder_id: 0=right/main, 1=left/deputy, 0xE=routing is not fixed
			
 
				+        #
			
 
				+        # 0xE does not mean "broken". On a Filament Track Switch machine it is the
			
 
				+        # normal steady state: the AMS is bound to a switch *inlet* rather than to
			
 
				+        # one extruder, and reaches both nozzles through it. Bits 24-27 then name
			
 
				+        # that inlet — 0 = In-B, 1 = In-A (BambuStudio's SwitchPos enum, which is
			
 
				+        # ordered B-then-A). Without an FTS, 0xE really is an uninitialised unit
			
 
				+        # and bits 24-27 carry nothing, which is why the inlet read is gated on
			
 
				+        # the switch being installed.
			
 
				         #
			
 
				         # Use merged_ams (not ams_list) to avoid partial MQTT updates overwriting
			
 
				         # the full map. Merge into existing map to preserve entries from prior updates.
			
 
				 
			
 
				+        fts_installed = self.state.fila_switch.installed
			
 
				+        inlet_moves: list[tuple[int, str]] = []
			
 
				         ams_extruder_map = dict(self.state.ams_extruder_map) if self.state.ams_extruder_map else {}
			
 
				+        ams_switch_inlet = dict(self.state.ams_switch_inlet) if self.state.ams_switch_inlet else {}
			
 
				         for ams_unit in merged_ams:
			
 
				             ams_id = ams_unit.get("id")
			
 
				             info = ams_unit.get("info")
			
@@ -3160,7 +3480,32 @@ class BambuMQTTClient:
 
				                     # Extract 4 bits starting at bit 8 for extruder assignment
			
 
				                     extruder_id = (info_val >> 8) & 0xF
			
 
				                     if extruder_id == 0xE:
			
 
				-                        # 0xE = uninitialized AMS, skip
			
 
				+                        if fts_installed:
			
 
				+                            inlet = {0: "B", 1: "A"}.get((info_val >> 24) & 0xF)
			
 
				+                            if inlet is not None:
			
 
				+                                previous = ams_switch_inlet.get(str(ams_id))
			
 
				+                                ams_switch_inlet[str(ams_id)] = inlet
			
 
				+                                self._debug_on_change(
			
 
				+                                    f"ams_inlet:{ams_id}",
			
 
				+                                    inlet,
			
 
				+                                    "[%s] AMS %s info=0x%s -> FTS inlet %s",
			
 
				+                                    self.serial_number,
			
 
				+                                    ams_id,
			
 
				+                                    info,
			
 
				+                                    inlet,
			
 
				+                                )
			
 
				+                                if previous is not None and previous != inlet:
			
 
				+                                    # Only a genuine move, never the first sighting:
			
 
				+                                    # re-applying K-profiles on every reconnect would
			
 
				+                                    # fight a binding the operator set deliberately.
			
 
				+                                    logger.info(
			
 
				+                                        "[%s] AMS %s moved to FTS inlet %s (was %s)",
			
 
				+                                        self.serial_number,
			
 
				+                                        ams_id,
			
 
				+                                        inlet,
			
 
				+                                        previous,
			
 
				+                                    )
			
 
				+                                    inlet_moves.append((int(ams_id), inlet))
			
 
				                         continue
			
 
				                     ams_extruder_map[str(ams_id)] = extruder_id
			
 
				                     self._debug_on_change(
			
@@ -3178,6 +3523,11 @@ class BambuMQTTClient:
 
				             self.state.raw_data["ams_extruder_map"] = ams_extruder_map
			
 
				             self.state.ams_extruder_map = ams_extruder_map
			
 
				             logger.debug("[%s] ams_extruder_map: %s", self.serial_number, ams_extruder_map)
			
 
				+        if ams_switch_inlet:
			
 
				+            self.state.ams_switch_inlet = ams_switch_inlet
			
 
				+        for moved_ams_id, moved_inlet in inlet_moves:
			
 
				+            if self.on_fts_inlet_change:
			
 
				+                self.on_fts_inlet_change(moved_ams_id, moved_inlet)
			
 
				 
			
 
				         # Extract drying status from info hex string and dry_sf_reason per AMS unit
			
 
				         # BambuStudio DevFilaSystem.cpp parses info bits:
			
@@ -3240,7 +3590,7 @@ class BambuMQTTClient:
 
				             # schedules smart-plug auto-off. dry_status comes from the same info
			
 
				             # hex parsed above; when it is absent we let the edge through, so a
			
 
				             # firmware that never reports one still ends its cycles.
			
 
				-            if current == 0 and ams_unit.get("dry_status") in _ACTIVE_DRY_STATUSES:
			
 
				+            if current == 0 and ams_unit.get("dry_status") in ACTIVE_DRY_STATUSES:
			
 
				                 # Leave the remembered value alone, exactly as the absent-
			
 
				                 # dry_time skip above does: whichever push ends the cycle for
			
 
				                 # real must still see a non-zero previous.
			
@@ -3931,20 +4281,11 @@ class BambuMQTTClient:
 
				                 if "cur" in ext_data:
			
 
				                     logger.debug("[%s] device.extruder.cur: %s", self.serial_number, ext_data["cur"])
			
 
				 
			
 
				-        # Filament Track Switch (FTS) detection — #1162. Presence of
			
 
				-        # device.fila_switch in MQTT means the FTS accessory is installed.
			
 
				-        if "device" in data and isinstance(data.get("device"), dict):
			
 
				-            fs_data = data["device"].get("fila_switch")
			
 
				-            if isinstance(fs_data, dict):
			
 
				-                in_raw = fs_data.get("in")
			
 
				-                out_raw = fs_data.get("out")
			
 
				-                self.state.fila_switch = FilaSwitchState(
			
 
				-                    installed=True,
			
 
				-                    in_slots=list(in_raw) if isinstance(in_raw, list) else [],
			
 
				-                    out_extruders=list(out_raw) if isinstance(out_raw, list) else [],
			
 
				-                    stat=int(fs_data.get("stat", 0) or 0),
			
 
				-                    info=int(fs_data.get("info", 0) or 0),
			
 
				-                )
			
 
				+        # Also parsed earlier in _process_message, because _handle_ams_data needs
			
 
				+        # it first. Repeated here so _update_state stays a complete "absorb this
			
 
				+        # payload" step for any other caller; re-parsing the same block is free.
			
 
				+        self._parse_fila_switch(data)
			
 
				+        self._parse_extruder_slots(data)
			
 
				 
			
 
				         if "bed_temper" in data:
			
 
				             temps["bed"] = float(data["bed_temper"])
			
@@ -4461,6 +4802,7 @@ class BambuMQTTClient:
 
				                                 actions=actions,
			
 
				                                 job_id=self.state.subtask_id,
			
 
				                                 full_code=full_code,
			
 
				+                                description=describe_fault(full_code),
			
 
				                             )
			
 
				                         )
			
 
				             self._apply_mqtt_verify_state(verify_failed)
			
@@ -4536,6 +4878,7 @@ class BambuMQTTClient:
 
				                                     # print_error is already 32-bit — `f"{print_error:08X}"`
			
 
				                                     # is the firmware's matching key with no truncation.
			
 
				                                     full_code=f"{print_error:08X}",
			
 
				+                                    description=describe_fault(f"{print_error:08X}"),
			
 
				                                 )
			
 
				                             )
			
 
				 
			
@@ -5113,7 +5456,16 @@ class BambuMQTTClient:
 
				             # Include HMS errors for failure reason detection
			
 
				             hms_errors_data = (
			
 
				                 [
			
 
				-                    {"code": e.code, "attr": e.attr, "module": e.module, "severity": e.severity}
			
 
				+                    {
			
 
				+                        "code": e.code,
			
 
				+                        "attr": e.attr,
			
 
				+                        "module": e.module,
			
 
				+                        "severity": e.severity,
			
 
				+                        # Carried so the queue's failure reason quotes the same
			
 
				+                        # sentence the status response and the broadcast do,
			
 
				+                        # rather than resolving the code a fourth time (#2926).
			
 
				+                        "description": e.description,
			
 
				+                    }
			
 
				                     for e in self.state.hms_errors
			
 
				                 ]
			
 
				                 if self.state.hms_errors
			
@@ -5753,6 +6105,9 @@ class BambuMQTTClient:
 
				                         command["print"]["nozzle_mapping"] = resolved
			
 
				 
			
 
				             logger.info("[%s] Sending print command: %s", self.serial_number, json.dumps(command))
			
 
				+            # Remember this dispatch so its echo on the topic is recognised as
			
 
				+            # ours rather than logged as a slicer's.
			
 
				+            self._own_project_file_key = self._project_file_key(command["print"])
			
 
				             self._client.publish(self.topic_publish, json.dumps(command), qos=1)
			
 
				             # Record what we dispatched so /cover can pick the right plate
			
 
				             # thumbnail even when the printer's gcode_file echo is just the
			
@@ -6193,6 +6548,33 @@ class BambuMQTTClient:
 
				                     logger.debug("Failed to parse K-profile from broadcast: %s", e)
			
 
				         return profiles
			
 
				 
			
 
				+    def _store_kprofiles(self, profiles: list, response_nozzle: str | None) -> None:
			
 
				+        """File one calibration-table response under its nozzle diameter.
			
 
				+
			
 
				+        ``response_nozzle`` names the table the printer just sent, so that
			
 
				+        bucket is replaced wholesale and every other one is left alone. When
			
 
				+        the envelope carries no diameter, fall back to the diameters the parsed
			
 
				+        profiles claim for themselves — and if there are none of those either,
			
 
				+        keep what we have rather than dropping a table we cannot attribute.
			
 
				+
			
 
				+        ``state.kprofiles`` stays a flat list because that is what its readers
			
 
				+        expect; the three assign paths already filter it by ``nozzle_diameter``
			
 
				+        and were quietly finding nothing whenever the last response happened to
			
 
				+        be for a different nozzle.
			
 
				+        """
			
 
				+        buckets: dict[str, list] = {}
			
 
				+        if response_nozzle:
			
 
				+            buckets[str(response_nozzle)] = list(profiles)
			
 
				+        else:
			
 
				+            for profile in profiles:
			
 
				+                buckets.setdefault(str(profile.nozzle_diameter), []).append(profile)
			
 
				+        if not buckets:
			
 
				+            return
			
 
				+        self._kprofiles_by_nozzle.update(buckets)
			
 
				+        self.state.kprofiles = [
			
 
				+            kp for nozzle in sorted(self._kprofiles_by_nozzle) for kp in self._kprofiles_by_nozzle[nozzle]
			
 
				+        ]
			
 
				+
			
 
				     def _handle_kprofile_response(self, data: dict):
			
 
				         """Handle K-profile response from printer."""
			
 
				         response_nozzle = data.get("nozzle_diameter")
			
@@ -6240,11 +6622,20 @@ class BambuMQTTClient:
 
				             return
			
 
				 
			
 
				         profiles = self._parse_kprofile_entries(filaments, response_nozzle, log_errors=request is not None)
			
 
				-        self.state.kprofiles = profiles
			
 
				+        self._store_kprofiles(profiles, response_nozzle)
			
 
				 
			
 
				         if request is None:
			
 
				             # Unsolicited broadcast with nothing in flight: state is refreshed,
			
 
				-            # nobody to wake.
			
 
				+            # nobody to wake. Worth a line — this is the printer answering
			
 
				+            # somebody else (BambuStudio queries the same report topic), and
			
 
				+            # until it was bucketed by nozzle it was also the quietest way for
			
 
				+            # the AMS card's K values to change underneath us.
			
 
				+            logger.debug(
			
 
				+                "[%s] Adopted unsolicited K-profile table: nozzle=%s, %d profiles",
			
 
				+                self.serial_number,
			
 
				+                response_nozzle or "?",
			
 
				+                len(profiles),
			
 
				+            )
			
 
				             return
			
 
				 
			
 
				         logger.info("[%s] Got %s K-profiles for nozzle=%s", self.serial_number, len(profiles), response_nozzle)
			
@@ -6982,7 +7373,16 @@ class BambuMQTTClient:
 
				             tray_id: Global tray ID — 0..15 for AMS slots, 254 for external spool
			
 
				                 (single-external printers and Ext-L on dual-nozzle H2D),
			
 
				                 255 for Ext-R on dual-nozzle H2D.
			
 
				-            extruder_id: Unused - kept for API compatibility
			
 
				+            extruder_id: Which hotend to feed (0 = right/main, 1 = left/deputy).
			
 
				+                Sent only when given, matching BambuStudio: ``extruder_id`` is
			
 
				+                an optional field on ``ams_change_filament``
			
 
				+                (``DeviceManager::command_ams_change_filament``) and Studio
			
 
				+                omits it unless a Filament Track Switch is installed. Without a
			
 
				+                switch the firmware derives the hotend from the AMS's own
			
 
				+                extruder binding and an explicit value is redundant; *with* one
			
 
				+                every AMS reports 0xE and is bound to a switch inlet instead, so
			
 
				+                the firmware has nothing to derive from and the load silently
			
 
				+                does nothing until we name the hotend.
			
 
				 
			
 
				         Returns:
			
 
				             True if command was sent, False otherwise
			
@@ -7037,6 +7437,8 @@ class BambuMQTTClient:
 
				                 "tar_temp": tar_temp,
			
 
				             }
			
 
				         }
			
 
				+        if extruder_id is not None:
			
 
				+            command["print"]["extruder_id"] = int(extruder_id)
			
 
				 
			
 
				         command_json = json.dumps(command)
			
 
				         logger.info("[%s] Publishing ams_change_filament command: %s", self.serial_number, command_json)
			
@@ -7051,8 +7453,21 @@ class BambuMQTTClient:
 
				 
			
 
				         return True
			
 
				 
			
 
				-    def ams_unload_filament(self) -> bool:
			
 
				-        """Unload the currently loaded filament.
			
 
				+    def ams_unload_filament(self, tray_id: int | None = None) -> bool:
			
 
				+        """Unload filament, optionally naming the slot to unload.
			
 
				+
			
 
				+        Args:
			
 
				+            tray_id: Global tray ID of the slot being unloaded. When given, the
			
 
				+                command is addressed to that slot's AMS and is only sent if an
			
 
				+                extruder is actually fed from it — BambuStudio does the same
			
 
				+                (``StatusPanel::on_ams_unload`` walks the extruders and sends
			
 
				+                nothing when none matches). When omitted, the pre-existing
			
 
				+                behaviour is kept: unload whatever ``tray_now`` names.
			
 
				+
			
 
				+        ``tray_now`` is a single value for the whole printer, so on a dual-nozzle
			
 
				+        machine with both hotends loaded it names only one of them and an
			
 
				+        unaddressed unload picks that one regardless of which slot the operator
			
 
				+        clicked. Passing the slot is what makes the two hotends distinguishable.
			
 
				 
			
 
				         Returns:
			
 
				             True if command was sent, False otherwise
			
@@ -7063,15 +7478,54 @@ class BambuMQTTClient:
 
				 
			
 
				         # Get the currently loaded tray info
			
 
				         tray_now = self.state.tray_now
			
 
				-        logger.info("[%s] Unload requested, tray_now=%s", self.serial_number, tray_now)
			
 
				+        source_tray = tray_now if tray_id is None else tray_id
			
 
				+        logger.info("[%s] Unload requested, tray_now=%s, tray_id=%s", self.serial_number, tray_now, tray_id)
			
 
				 
			
 
				         # Determine source ams_id for the unload command
			
 
				-        if tray_now == 255 or tray_now == 254:
			
 
				+        if source_tray == 255 or source_tray == 254:
			
 
				             ams_id = 255  # No filament or external spool
			
 
				-        elif (_a2l := a2l_lite_wire_ids(tray_now // 4, tray_now)) is not None:
			
 
				+        elif (_a2l := a2l_lite_wire_ids(source_tray // 4, source_tray)) is not None:
			
 
				             ams_id = _a2l[0]  # A2L AMS-Lite: normalised 6 -> physical 16
			
 
				         else:
			
 
				-            ams_id = tray_now // 4  # Source AMS
			
 
				+            ams_id = source_tray // 4  # Source AMS
			
 
				+
			
 
				+        # Refuse an addressed unload of a slot no hotend is holding — but only on
			
 
				+        # a printer that has more than one hotend, which is the only case the
			
 
				+        # check exists for. With one hotend there is nothing to disambiguate:
			
 
				+        # tray_now already names the loaded slot exactly, and running the check
			
 
				+        # anyway would stake unload on `snow` meaning ams*4+slot there too. It
			
 
				+        # very likely does, but single-nozzle machines do report the block —
			
 
				+        # BambuStudio has a dedicated branch for `m_total_extder_count == 1` and
			
 
				+        # an X1C on the maintainer's own network sends `device.extruder` — and
			
 
				+        # nobody has read a single-nozzle `snow` off the wire. Guessing wrong
			
 
				+        # would 409 every unload on every X1C, P1S and A1.
			
 
				+        #
			
 
				+        # Gated on the runtime flag rather than on len(extruder_slots), which is
			
 
				+        # rebuilt from each payload's array and would flip the check off for any
			
 
				+        # frame that carried a short one; and deliberately not on
			
 
				+        # ``is_dual_nozzle_model``, whose model-name fallback reports at least
			
 
				+        # one single-nozzle machine as dual (#1386) — the false positive there is
			
 
				+        # exactly the case this gate exists to keep out.
			
 
				+        #
			
 
				+        # The external spool is excluded for a different reason: 254/255 are not
			
 
				+        # ams*4+slot, so the local-slot arithmetic below cannot describe them.
			
 
				+        if tray_id is not None and tray_id not in (254, 255) and self._is_dual_nozzle and self.state.extruder_slots:
			
 
				+            local_slot = _a2l[1] if (_a2l := a2l_lite_wire_ids(tray_id // 4, tray_id)) is not None else tray_id % 4
			
 
				+            holder = next(
			
 
				+                (ext for ext, slot in self.state.extruder_slots.items() if slot.holds(ams_id, local_slot)),
			
 
				+                None,
			
 
				+            )
			
 
				+            if holder is None:
			
 
				+                logger.info(
			
 
				+                    "[%s] Unload skipped: no extruder is fed from AMS %s slot %s",
			
 
				+                    self.serial_number,
			
 
				+                    ams_id,
			
 
				+                    local_slot,
			
 
				+                )
			
 
				+                return False
			
 
				+            logger.info(
			
 
				+                "[%s] Unloading AMS %s slot %s from extruder %s", self.serial_number, ams_id, local_slot, holder
			
 
				+            )
			
 
				 
			
 
				         # Command format from BambuStudio traffic capture:
			
 
				         # - No extruder_id field
			
@@ -7254,7 +7708,9 @@ class BambuMQTTClient:
 
				                 "tray_info_idx": tray_info_idx,
			
 
				                 "tray_type": tray_type,
			
 
				                 "tray_sub_brands": tray_sub_brands,
			
 
				-                "tray_color": tray_color,
			
 
				+                # UPPERCASE, always: lowercase hex is silently read as zeros by
			
 
				+                # P1S firmware and acknowledged as a success (#2987).
			
 
				+                "tray_color": wire_tray_color(tray_color),
			
 
				                 "nozzle_temp_min": nozzle_temp_min,
			
 
				                 "nozzle_temp_max": nozzle_temp_max,
			
 
				                 "sequence_id": "0",
			
--- a/backend/app/services/camera.py
+++ b/backend/app/services/camera.py
@@ -17,7 +17,7 @@ import uuid
 
				 from datetime import datetime
			
 
				 from pathlib import Path
			
 
				 
			
 
				-from backend.app.core.logging_filters import redact_url_credentials
			
 
				+from backend.app.utils.ffmpeg_output import NO_FFMPEG_OUTPUT, summarize_ffmpeg_stderr
			
 
				 
			
 
				 logger = logging.getLogger(__name__)
			
 
				 
			
@@ -231,7 +231,8 @@ async def create_tls_proxy(target_host: str, target_port: int) -> tuple[int, "as
 
				     rewrites ``127.0.0.1:<proxy_port>`` → ``<target_host>:<target_port>`` in
			
 
				     client→server data so the printer recognises the stream path.
			
 
				 
			
 
				-    Returns ``(local_port, server)``.  Caller must close the server when done.
			
 
				+    Returns ``(local_port, server)``.  Caller must close it with
			
 
				+    :func:`close_tls_proxy` when done.
			
 
				     """
			
 
				     ssl_ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
			
 
				     ssl_ctx.check_hostname = False
			
@@ -240,7 +241,20 @@ async def create_tls_proxy(target_host: str, target_port: int) -> tuple[int, "as
 
				     # Filled in after the server socket is created (handler only runs after).
			
 
				     _local_port: list[int] = [0]
			
 
				 
			
 
				+    # Strong references to the in-flight connection handlers (#2968).
			
 
				+    # ``asyncio.start_server`` wraps the callback in a task and keeps only a
			
 
				+    # weak reference to it, so a handler still awaiting its two forwarders can
			
 
				+    # be garbage-collected out from under itself — which is asyncio's
			
 
				+    # "Task was destroyed but it is pending!", logged at ERROR with a traceback
			
 
				+    # pointing here and no indication that it is a teardown race rather than a
			
 
				+    # camera fault. Holding the set also gives close_tls_proxy something to
			
 
				+    # cancel, so shutdown stops depending on ffmpeg having dropped its end.
			
 
				+    handlers: set[asyncio.Task] = set()
			
 
				+
			
 
				     async def _handle(client_reader: asyncio.StreamReader, client_writer: asyncio.StreamWriter):
			
 
				+        current = asyncio.current_task()
			
 
				+        if current is not None:
			
 
				+            handlers.add(current)
			
 
				         tls_writer = None
			
 
				         try:
			
 
				             tls_reader, tls_writer = await asyncio.wait_for(
			
@@ -305,7 +319,19 @@ async def create_tls_proxy(target_host: str, target_port: int) -> tuple[int, "as
 
				             )
			
 
				         except (ConnectionError, OSError, TimeoutError) as e:
			
 
				             logger.debug("TLS proxy connection to %s:%s failed: %s", target_host, target_port, e)
			
 
				+        except asyncio.CancelledError:
			
 
				+            # close_tls_proxy cancelling us at shutdown, which is the only thing
			
 
				+            # that cancels this task. Swallowing a cancellation is normally
			
 
				+            # wrong because it hides the request from whoever made it; here we
			
 
				+            # *are* whoever made it, the cleanup it exists to trigger is in the
			
 
				+            # finally below, and nothing awaits this task's result. Asyncio's
			
 
				+            # own done-callback for a connection handler treats a cancelled task
			
 
				+            # differently from a completed one, so ending in the ordinary way
			
 
				+            # keeps the teardown on one path across Python versions.
			
 
				+            pass
			
 
				         finally:
			
 
				+            if current is not None:
			
 
				+                handlers.discard(current)
			
 
				             for w in (client_writer, tls_writer):
			
 
				                 if w and not w.is_closing():
			
 
				                     try:
			
@@ -315,10 +341,36 @@ async def create_tls_proxy(target_host: str, target_port: int) -> tuple[int, "as
 
				 
			
 
				     server = await asyncio.start_server(_handle, "127.0.0.1", 0)
			
 
				     _local_port[0] = server.sockets[0].getsockname()[1]
			
 
				+    server._bambuddy_proxy_handlers = handlers  # type: ignore[attr-defined]
			
 
				     logger.debug("TLS proxy for %s:%s listening on 127.0.0.1:%s", target_host, target_port, _local_port[0])
			
 
				     return _local_port[0], server
			
 
				 
			
 
				 
			
 
				+async def close_tls_proxy(server: "asyncio.Server") -> None:
			
 
				+    """Shut a :func:`create_tls_proxy` server down without leaving tasks behind.
			
 
				+
			
 
				+    ``server.close()`` stops the listener but leaves established connections
			
 
				+    running, and ``wait_closed()`` is only as deterministic as the peer: it
			
 
				+    waits for the handlers, and a handler waits for ffmpeg to drop its end of
			
 
				+    the socket. By the time this is called ffmpeg has already been reaped, so
			
 
				+    the connection is dead weight — cancelling it is both correct and the only
			
 
				+    way to guarantee no handler outlives the server that owns it.
			
 
				+
			
 
				+    ``Server.close_clients()`` would do this natively, but it landed in Python
			
 
				+    3.13 and Bambuddy supports 3.10, so the handler set is tracked by hand.
			
 
				+
			
 
				+    Safe to call on a plain ``asyncio.Server`` from anywhere else: without the
			
 
				+    attribute it degrades to the close/wait it replaces.
			
 
				+    """
			
 
				+    handlers: set[asyncio.Task] = getattr(server, "_bambuddy_proxy_handlers", set())
			
 
				+    server.close()
			
 
				+    for task in list(handlers):
			
 
				+        task.cancel()
			
 
				+    if handlers:
			
 
				+        await asyncio.gather(*list(handlers), return_exceptions=True)
			
 
				+    await server.wait_closed()
			
 
				+
			
 
				+
			
 
				 def is_chamber_image_model(model: str | None) -> bool:
			
 
				     """Check if printer uses chamber image protocol instead of RTSP.
			
 
				 
			
@@ -692,8 +744,7 @@ async def _capture_camera_frame_bytes_uncoalesced(
 
				 
			
 
				     ffmpeg = get_ffmpeg_path()
			
 
				     if not ffmpeg:
			
 
				-        proxy_server.close()
			
 
				-        await proxy_server.wait_closed()
			
 
				+        await close_tls_proxy(proxy_server)
			
 
				         logger.error("ffmpeg not found for camera frame capture")
			
 
				         return None
			
 
				 
			
@@ -740,9 +791,11 @@ async def _capture_camera_frame_bytes_uncoalesced(
 
				             logger.info("Successfully captured camera frame bytes: %s bytes", len(stdout))
			
 
				             return stdout
			
 
				         else:
			
 
				-            # ffmpeg echoes the RTSP input URL, which carries the access code.
			
 
				-            stderr_text = redact_url_credentials(stderr.decode()) if stderr else "Unknown error"
			
 
				-            logger.error("ffmpeg frame bytes capture failed (code %s): %s", process.returncode, stderr_text[:200])
			
 
				+            # The summariser drops ffmpeg's banner and masks the access code
			
 
				+            # the RTSP input URL carries; without it this line was 200
			
 
				+            # characters of build configuration (#2968).
			
 
				+            stderr_text = summarize_ffmpeg_stderr(stderr) or NO_FFMPEG_OUTPUT
			
 
				+            logger.error("ffmpeg frame bytes capture failed (code %s): %s", process.returncode, stderr_text)
			
 
				             return None
			
 
				 
			
 
				     except FileNotFoundError:
			
@@ -754,8 +807,7 @@ async def _capture_camera_frame_bytes_uncoalesced(
 
				     finally:
			
 
				         if process is not None:
			
 
				             _active_capture_pids.discard(process.pid)
			
 
				-        proxy_server.close()
			
 
				-        await proxy_server.wait_closed()
			
 
				+        await close_tls_proxy(proxy_server)
			
 
				 
			
 
				 
			
 
				 async def extract_video_last_frame(video_path: Path, output_path: Path) -> bool:
			
@@ -815,7 +867,7 @@ async def extract_video_last_frame(video_path: Path, output_path: Path) -> bool:
 
				             logger.warning(
			
 
				                 "ffmpeg failed extracting last frame from %s: %s",
			
 
				                 video_path,
			
 
				-                stderr.decode(errors="replace")[:500],
			
 
				+                summarize_ffmpeg_stderr(stderr) or NO_FFMPEG_OUTPUT,
			
 
				             )
			
 
				             return False
			
 
				         if not output_path.exists() or output_path.stat().st_size == 0:
			
--- a/backend/app/services/design_settings.py
+++ b/backend/app/services/design_settings.py
@@ -53,6 +53,10 @@ class DesignOverride(NamedTuple):
 
				     key: str
			
 
				     value: Any
			
 
				     printer_coupled: bool
			
 
				+    # Set for the handful of keys that *define* the picked process preset —
			
 
				+    # see :data:`_PRESET_DEFINING`. Offered like printer-coupled ones, never
			
 
				+    # pre-selected, because the user's preset pick has to win over the file.
			
 
				+    preset_defining: bool = False
			
 
				 
			
 
				 
			
 
				 # Process keys whose sane value depends on the machine, not on the design intent.
			
@@ -93,6 +97,29 @@ _PRINTER_COUPLED_SUBSTRINGS: tuple[str, ...] = (
 
				 )
			
 
				 
			
 
				 
			
 
				+# Process keys whose value *is* the preset the user picked. "0.08mm High
			
 
				+# Quality" is not a name with a layer height attached — the layer height is
			
 
				+# what the preset is, and the same holds for the first layer it starts on.
			
 
				+#
			
 
				+# Carrying these from the file would quietly undo an explicit pick: choose the
			
 
				+# 0.08 preset for a MakerWorld file whose designer moved layer height to 0.2
			
 
				+# and, with every non-printer-coupled key pre-selected, the slice comes out at
			
 
				+# 0.2 while the dropdown still reads 0.08. The designer's value stays on offer
			
 
				+# — a re-slice that genuinely wants the design's layer height is one tick away
			
 
				+# — but nothing here is applied without the user saying so.
			
 
				+_PRESET_DEFINING: frozenset[str] = frozenset(
			
 
				+    {
			
 
				+        "layer_height",
			
 
				+        "initial_layer_print_height",
			
 
				+    }
			
 
				+)
			
 
				+
			
 
				+
			
 
				+def is_preset_defining(key: str) -> bool:
			
 
				+    """Whether this key is the identity of the picked process preset."""
			
 
				+    return key in _PRESET_DEFINING
			
 
				+
			
 
				+
			
 
				 def is_printer_coupled(key: str) -> bool:
			
 
				     """Whether carrying this process key across printer models is risky."""
			
 
				     if key in _PRINTER_COUPLED_EXACT:
			
@@ -159,7 +186,14 @@ def overrides_from_config(config: Any) -> list[DesignOverride]:
 
				             # Listed as changed but absent from the flattened config — nothing
			
 
				             # to carry. Seen with keys the slicer renamed between versions.
			
 
				             continue
			
 
				-        overrides.append(DesignOverride(key=key, value=config[key], printer_coupled=is_printer_coupled(key)))
			
 
				+        overrides.append(
			
 
				+            DesignOverride(
			
 
				+                key=key,
			
 
				+                value=config[key],
			
 
				+                printer_coupled=is_printer_coupled(key),
			
 
				+                preset_defining=is_preset_defining(key),
			
 
				+            )
			
 
				+        )
			
 
				 
			
 
				     overrides.sort(key=lambda o: o.key)
			
 
				     return overrides
			
--- a/backend/app/services/drying_preflight.py
+++ b/backend/app/services/drying_preflight.py
@@ -0,0 +1,117 @@
 
				+"""Shared checks run before an AMS drying command is sent.
			
 
				+
			
 
				+Both the immediate POST /printers/{id}/drying/start endpoint and the
			
 
				+scheduler's delayed dispatch go through here, so a run that the immediate
			
 
				+path would refuse is never silently published by the scheduled path.
			
 
				+"""
			
 
				+
			
 
				+from backend.app.services.printer_manager import drying_screen_only, supports_drying
			
 
				+
			
 
				+SCREEN_ONLY_DETAIL = "This printer only supports AMS drying from its own screen"
			
 
				+UNSUPPORTED_DETAIL = "Drying not supported for this printer model or firmware version"
			
 
				+
			
 
				+# Firmware dry_sf_reason codes, as surfaced by the AMS status payload.
			
 
				+DRY_SF_REASON_MESSAGES = {
			
 
				+    0: "Printer is busy",
			
 
				+    1: "Insufficient power: too many AMS drying or external PSU required",
			
 
				+    2: "AMS is busy",
			
 
				+    3: "Filament is at the AMS outlet, retract it first",
			
 
				+    4: "AMS is already starting a drying cycle",
			
 
				+    5: "Not supported in 2D mode",
			
 
				+    6: "AMS is already drying",
			
 
				+    7: "AMS firmware is upgrading",
			
 
				+    8: "Plug in the external AMS power adapter to start drying",
			
 
				+}
			
 
				+
			
 
				+# Codes 1 and 8 mean a power-supply problem the user has to fix; the rest
			
 
				+# clear on their own. The frontend splits blocked states the same way.
			
 
				+POWER_REASON_CODES = frozenset({1, 8})
			
 
				+
			
 
				+# Code 3 also needs the user to act, but the fix is retracting filament rather
			
 
				+# than anything to do with power, so it gets its own token instead of the
			
 
				+# generic "cannot dry right now" the transient codes share.
			
 
				+RETRACT_REASON_CODE = 3
			
 
				+
			
 
				+WAITING_REASON_POWER = "ams_power_required"
			
 
				+WAITING_REASON_RETRACT = "ams_retract_filament"
			
 
				+WAITING_REASON_BLOCKED = "ams_blocked"
			
 
				+
			
 
				+
			
 
				+def check_drying_supported(model: str | None, firmware: str | None, *, require_firmware: bool = True) -> str | None:
			
 
				+    """Return a message if this printer cannot dry, else None.
			
 
				+
			
 
				+    Pass require_firmware=False when there is no live status to read a version
			
 
				+    from, which leaves only the model check. Dispatch always has a status and
			
 
				+    judges both.
			
 
				+    """
			
 
				+    if drying_screen_only(model):
			
 
				+        return SCREEN_ONLY_DETAIL
			
 
				+    if require_firmware and not supports_drying(model, firmware):
			
 
				+        return UNSUPPORTED_DETAIL
			
 
				+    return None
			
 
				+
			
 
				+
			
 
				+def find_ams_unit(state, ams_id: int) -> dict | None:
			
 
				+    """Locate an AMS unit in a live printer status payload."""
			
 
				+    for unit in (state.raw_data.get("ams") if state else None) or []:
			
 
				+        try:
			
 
				+            if int(unit.get("id", -1)) == ams_id:
			
 
				+                return unit
			
 
				+        except (TypeError, ValueError):
			
 
				+            continue
			
 
				+    return None
			
 
				+
			
 
				+
			
 
				+def blocking_reason_codes(unit: dict | None) -> list[int]:
			
 
				+    """Known dry_sf_reason codes on this unit, in reported order."""
			
 
				+    codes = []
			
 
				+    for code in (unit or {}).get("dry_sf_reason") or []:
			
 
				+        try:
			
 
				+            code_int = int(code)
			
 
				+        except (TypeError, ValueError):
			
 
				+            continue
			
 
				+        if code_int in DRY_SF_REASON_MESSAGES:
			
 
				+            codes.append(code_int)
			
 
				+    return codes
			
 
				+
			
 
				+
			
 
				+def primary_reason_code(codes: list[int]) -> int | None:
			
 
				+    """The one code to report when the AMS sets several at once.
			
 
				+
			
 
				+    Power and filament-at-the-outlet need the user to go and do something; the
			
 
				+    rest clear on their own. Naming an actionable one is more use than whichever
			
 
				+    the firmware happened to list first, and going through here keeps the
			
 
				+    immediate endpoint's message and the scheduled row's waiting_reason
			
 
				+    describing the same blocked AMS the same way.
			
 
				+    """
			
 
				+    for code in codes:
			
 
				+        if code in POWER_REASON_CODES:
			
 
				+            return code
			
 
				+    if RETRACT_REASON_CODE in codes:
			
 
				+        return RETRACT_REASON_CODE
			
 
				+    return codes[0] if codes else None
			
 
				+
			
 
				+
			
 
				+def waiting_reason_for_codes(codes: list[int]) -> str:
			
 
				+    """Map blocking codes onto the token the frontend translates."""
			
 
				+    code = primary_reason_code(codes)
			
 
				+    if code in POWER_REASON_CODES:
			
 
				+        return WAITING_REASON_POWER
			
 
				+    if code == RETRACT_REASON_CODE:
			
 
				+        return WAITING_REASON_RETRACT
			
 
				+    return WAITING_REASON_BLOCKED
			
 
				+
			
 
				+
			
 
				+def resolve_filament(unit: dict | None, filament: str) -> str:
			
 
				+    """Fill an empty filament field from the first loaded tray.
			
 
				+
			
 
				+    The printer rejects a drying payload with no filament type, so both
			
 
				+    callers fall back to the loaded spool and then to PLA.
			
 
				+    """
			
 
				+    if filament:
			
 
				+        return filament
			
 
				+    for tray in (unit or {}).get("tray") or []:
			
 
				+        tray_type = tray.get("tray_type")
			
 
				+        if tray_type:
			
 
				+            return str(tray_type)
			
 
				+    return "PLA"
			
--- a/backend/app/services/energy_plug.py
+++ b/backend/app/services/energy_plug.py
@@ -0,0 +1,104 @@
 
				+"""Which of a printer's plugs measures its energy? (#2859)
			
 
				+
			
 
				+Per-print energy is the delta of one plug's lifetime counter between print start
			
 
				+and print end, so both readings have to come from the same plug. The two call
			
 
				+sites used to assume a printer had exactly one: they selected every plug with
			
 
				+``SmartPlug.printer_id == printer_id`` and then called ``scalar_one_or_none()``.
			
 
				+
			
 
				+Nothing enforces that assumption. The plug API rejects a second *Tasmota* plug
			
 
				+on a printer and deliberately allows any number of Home Assistant entities --
			
 
				+"allow multiple per printer (for different automations)" -- which is how a
			
 
				+filter fan, a dry box or a lights script ends up linked beside the printer's own
			
 
				+plug. On those installs the query returned two rows, ``scalar_one_or_none()``
			
 
				+raised, the print-start handler caught it as just another failure and logged a
			
 
				+warning, and no archive on that printer ever carried an energy figure again. It
			
 
				+was silent because the print-end handler then reports "no start kWh recorded",
			
 
				+which reads exactly like "this printer has no plug".
			
 
				+
			
 
				+The rule below picks the printer's own plug without asking the user to nominate
			
 
				+one. ``controls_printer_power`` (#2629) already means "this plug really feeds
			
 
				+the printer" rather than an accessory that merely follows the print cycle, so it
			
 
				+ranks above one that does not, and the id breaks ties so the start and end
			
 
				+readings agree on the answer. The decisive test in practice is the last one: a
			
 
				+candidate has to actually report a lifetime counter to be chosen, and accessory
			
 
				+plugs are usually switch-only, so they drop out with nothing configured.
			
 
				+
			
 
				+Deliberately *not* enforced: one plug per printer. Bambuddy dropped the UNIQUE
			
 
				+constraint on ``smart_plugs.printer_id`` on purpose, and the flag defaults to on
			
 
				+for every existing plug, so clearing it to make it unique would change which
			
 
				+plugs may mark a printer offline on auto-off (#2629) -- not this module's
			
 
				+business.
			
 
				+
			
 
				+Equally deliberate: nothing is excluded, only ranked. A printer with one linked
			
 
				+plug used it whatever it was, and must keep doing so, so a disabled row or a
			
 
				+script still gets its turn once the plausible candidates have declined.
			
 
				+"""
			
 
				+
			
 
				+from __future__ import annotations
			
 
				+
			
 
				+from collections.abc import Awaitable, Callable
			
 
				+
			
 
				+from sqlalchemy import select
			
 
				+from sqlalchemy.ext.asyncio import AsyncSession
			
 
				+
			
 
				+from backend.app.models.smart_plug import SmartPlug
			
 
				+
			
 
				+# Reads a plug's energy dict, or None when the device did not answer. Injected
			
 
				+# rather than imported so this module stays independent of the plug-type
			
 
				+# dispatch that lives with the callers.
			
 
				+EnergyReader = Callable[[SmartPlug, AsyncSession], Awaitable[dict | None]]
			
 
				+
			
 
				+
			
 
				+def _is_script_entity(plug: SmartPlug) -> bool:
			
 
				+    """A Home Assistant ``script.*`` entity linked to a printer for automation.
			
 
				+
			
 
				+    Stored as plugs so they can follow the print cycle (see
			
 
				+    ``trigger_associated_scripts``), but a script has nothing to meter.
			
 
				+    """
			
 
				+    return bool(plug.plug_type == "homeassistant" and plug.ha_entity_id and plug.ha_entity_id.startswith("script."))
			
 
				+
			
 
				+
			
 
				+def _rank(plug: SmartPlug) -> tuple:
			
 
				+    """Sort key: least surprising source of a printer's meter first.
			
 
				+
			
 
				+    Ranking rather than filtering, deliberately. A printer with exactly one
			
 
				+    linked row behaved the same before this module existed whatever that row
			
 
				+    was -- disabled, a script, an accessory -- and it has to keep behaving that
			
 
				+    way, so nothing is excluded outright and every rejection is left to the one
			
 
				+    test that cannot be wrong: does it actually report a counter.
			
 
				+    """
			
 
				+    return (
			
 
				+        _is_script_entity(plug),
			
 
				+        not plug.enabled,
			
 
				+        not plug.controls_printer_power,
			
 
				+        plug.id,
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+async def energy_plug_candidates(db: AsyncSession, printer_id: int | None) -> list[SmartPlug]:
			
 
				+    """Plugs on *printer_id* that could supply its energy counter, best first."""
			
 
				+    if printer_id is None:
			
 
				+        # `printer_id == None` compiles to `IS NULL`, which would return every
			
 
				+        # plug linked to no printer at all and bill a print against whichever
			
 
				+        # one happened to answer. Callers are typed `int`, so this is a guard
			
 
				+        # against a future one rather than a live path.
			
 
				+        return []
			
 
				+    result = await db.execute(select(SmartPlug).where(SmartPlug.printer_id == printer_id))
			
 
				+    return sorted(result.scalars().all(), key=_rank)
			
 
				+
			
 
				+
			
 
				+async def select_energy_reading(
			
 
				+    candidates: list[SmartPlug],
			
 
				+    read_energy: EnergyReader,
			
 
				+    db: AsyncSession,
			
 
				+) -> tuple[SmartPlug, dict] | None:
			
 
				+    """First candidate that actually reports a lifetime counter, with its reading.
			
 
				+
			
 
				+    Returns the reading alongside the plug so the caller does not poll twice --
			
 
				+    the value that decided the choice is the value it needs.
			
 
				+    """
			
 
				+    for plug in candidates:
			
 
				+        energy = await read_energy(plug, db)
			
 
				+        if energy and energy.get("total") is not None:
			
 
				+            return plug, energy
			
 
				+    return None
			
--- a/backend/app/services/external_camera.py
+++ b/backend/app/services/external_camera.py
@@ -21,6 +21,7 @@ from urllib.parse import urlparse
 
				 import aiohttp
			
 
				 
			
 
				 from backend.app.core.logging_filters import redact_url_credentials
			
 
				+from backend.app.utils.ffmpeg_output import NO_FFMPEG_OUTPUT, summarize_ffmpeg_stderr
			
 
				 
			
 
				 logger = logging.getLogger(__name__)
			
 
				 
			
@@ -517,7 +518,7 @@ async def _capture_usb_frame(device: str, timeout: int) -> bytes | None:
 
				         stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout)
			
 
				 
			
 
				         if process.returncode != 0:
			
 
				-            logger.error("ffmpeg USB capture failed: %s", stderr.decode()[:200])
			
 
				+            logger.error("ffmpeg USB capture failed: %s", summarize_ffmpeg_stderr(stderr) or NO_FFMPEG_OUTPUT)
			
 
				             return None
			
 
				 
			
 
				         if not stdout or len(stdout) < 100:
			
@@ -701,8 +702,8 @@ async def _capture_rtsp_frame(url: str, timeout: int) -> bytes | None:
 
				         )
			
 
				 
			
 
				         if process.returncode != 0:
			
 
				-            # ffmpeg echoes the RTSP input URL, which carries the camera password.
			
 
				-            logger.error("ffmpeg RTSP capture failed: %s", redact_url_credentials(stderr.decode())[:200])
			
 
				+            # The summariser masks the camera password the input URL carries.
			
 
				+            logger.error("ffmpeg RTSP capture failed: %s", summarize_ffmpeg_stderr(stderr) or NO_FFMPEG_OUTPUT)
			
 
				             return None
			
 
				 
			
 
				         if not stdout or len(stdout) < 100:
			
@@ -1149,8 +1150,10 @@ async def _stream_rtsp(
 
				         await asyncio.sleep(0.1)
			
 
				         if process.returncode is not None:
			
 
				             stderr = await process.stderr.read()
			
 
				-            # ffmpeg echoes the RTSP input URL, which carries the camera password.
			
 
				-            logger.error("ffmpeg RTSP stream failed immediately: %s", redact_url_credentials(stderr.decode())[:300])
			
 
				+            # The summariser masks the camera password the input URL carries.
			
 
				+            logger.error(
			
 
				+                "ffmpeg RTSP stream failed immediately: %s", summarize_ffmpeg_stderr(stderr) or NO_FFMPEG_OUTPUT
			
 
				+            )
			
 
				             return
			
 
				 
			
 
				         buffer = b""
			
@@ -1262,7 +1265,9 @@ async def _stream_usb(
 
				         await asyncio.sleep(0.5)
			
 
				         if process.returncode is not None:
			
 
				             stderr = await process.stderr.read()
			
 
				-            logger.error("ffmpeg USB stream failed immediately: %s", stderr.decode()[:300])
			
 
				+            logger.error(
			
 
				+                "ffmpeg USB stream failed immediately: %s", summarize_ffmpeg_stderr(stderr) or NO_FFMPEG_OUTPUT
			
 
				+            )
			
 
				             return
			
 
				 
			
 
				         buffer = b""
			
--- a/backend/app/services/failure_analysis.py
+++ b/backend/app/services/failure_analysis.py
@@ -151,6 +151,25 @@ class FailureAnalysisService:
 
				                 select(Printer.id, Printer.name).where(Printer.id.in_(failures_by_printer_id.keys()))
			
 
				             )
			
 
				             printer_names = {row[0]: row[1] for row in printers_result.fetchall()}
			
 
				+            # A printer deleted with its history kept has no row left to read a
			
 
				+            # name from, and "Printer 3" tells nobody which machine kept failing
			
 
				+            # (#2873). Each run recorded the name it printed on, so fall back to
			
 
				+            # the last one that id was known by.
			
 
				+            missing = [pid for pid in failures_by_printer_id if pid not in printer_names]
			
 
				+            if missing:
			
 
				+                last_named_run = (
			
 
				+                    select(func.max(PrintLogEntry.id).label("entry_id"))
			
 
				+                    .where(PrintLogEntry.printer_id.in_(missing), PrintLogEntry.printer_name.isnot(None))
			
 
				+                    .group_by(PrintLogEntry.printer_id)
			
 
				+                    .subquery()
			
 
				+                )
			
 
				+                historic_result = await self.db.execute(
			
 
				+                    select(PrintLogEntry.printer_id, PrintLogEntry.printer_name).join(
			
 
				+                        last_named_run, PrintLogEntry.id == last_named_run.c.entry_id
			
 
				+                    )
			
 
				+                )
			
 
				+                for pid, name in historic_result.fetchall():
			
 
				+                    printer_names[pid] = name
			
 
				             failures_by_printer = {
			
 
				                 printer_names.get(pid, f"Printer {pid}"): count for pid, count in failures_by_printer_id.items()
			
 
				             }
			
--- a/backend/app/services/filament_deficit.py
+++ b/backend/app/services/filament_deficit.py
@@ -38,6 +38,7 @@ from sqlalchemy import select
 
				 from sqlalchemy.ext.asyncio import AsyncSession
			
 
				 from sqlalchemy.orm import selectinload
			
 
				 
			
 
				+from backend.app.api.routes._spoolman_helpers import _map_spoolman_spool
			
 
				 from backend.app.core.config import settings as app_settings
			
 
				 from backend.app.models.print_queue import PrintQueueItem
			
 
				 from backend.app.models.spool_assignment import SpoolAssignment
			
@@ -186,7 +187,15 @@ def _normalize_color_for_id(raw: str | None) -> str:
 
				     Strips the leading ``#``, uppercases, and drops the alpha channel when
			
 
				     the hex is 8 chars long (``RRGGBBAA``) so a fully-opaque 8-char hex
			
 
				     matches a 6-char hex of the same RGB. Empty / None → empty string.
			
 
				+
			
 
				+    Anything that is not a string reads as "no colour" rather than raising.
			
 
				+    In Spoolman mode ``raw`` comes straight off the wire as
			
 
				+    ``filament.color_hex``, and this runs on the dispatch path — a record
			
 
				+    holding a number there would otherwise fail a queue start rather than
			
 
				+    merely fail to pool.
			
 
				     """
			
 
				+    if not isinstance(raw, str):
			
 
				+        raw = None
			
 
				     s = (raw or "").strip().lstrip("#").upper()
			
 
				     if len(s) == 8:  # RRGGBBAA → strip alpha
			
 
				         s = s[:6]
			
@@ -225,9 +234,14 @@ def _material_identity_spoolman(spool: dict | None) -> str:
 
				     pins the variant. Spools without a resolvable filament id get a
			
 
				     per-spool unique key so they never pair.
			
 
				     """
			
 
				-    if not spool:
			
 
				+    if not isinstance(spool, dict) or not spool:
			
 
				         return "unmatched:none"
			
 
				+    # Both are free-form JSON off the Spoolman API, and this is the dispatch
			
 
				+    # path: a wrongly-typed member must cost the slot its pool, never the
			
 
				+    # queue its start.
			
 
				     filament = spool.get("filament") or {}
			
 
				+    if not isinstance(filament, dict):
			
 
				+        filament = {}
			
 
				     fil_id = filament.get("id")
			
 
				     if isinstance(fil_id, (int, str)) and str(fil_id).strip():
			
 
				         # Prefer the per-spool override colour when set (Spoolman lets the user
			
@@ -301,6 +315,102 @@ async def _get_printer_backup_context(
 
				     return backup_on, ams_extruder_map, is_dual
			
 
				 
			
 
				 
			
 
				+@dataclass(frozen=True)
			
 
				+class SlotSpoolIdentity:
			
 
				+    """How the spool bound to a slot should be *named*, as opposed to matched.
			
 
				+
			
 
				+    The printer cannot supply this and never will. A tray record carries no
			
 
				+    brand field at all, and ``tray_sub_brands`` stays empty for anything that
			
 
				+    isn't a Bambu spool, so a client naming a slot from telemetry alone has
			
 
				+    only the type and the colour hex to work with — and turns that hex into
			
 
				+    whichever catalogue colour happens to share it. A Devil Design PLA Basic
			
 
				+    Orange the operator assigned in Bambuddy reads back as "PLA (Sunflower
			
 
				+    Yellow)", because Bambu sell a Sunflower Yellow at the same ``FEC600``.
			
 
				+
			
 
				+    Only the assignment knows the answer, which is why it is served alongside
			
 
				+    the pooling key rather than left to the client to resolve: the identity
			
 
				+    rule differs per inventory mode, and the printer card and the print dialog
			
 
				+    disagreeing about what is in a slot is the bug this exists to close.
			
 
				+
			
 
				+    Purely descriptive — nothing here takes part in matching, which stays on
			
 
				+    the printer's own telemetry so the dialog and the dispatcher cannot draw
			
 
				+    different conclusions from the same slot.
			
 
				+    """
			
 
				+
			
 
				+    brand: str | None
			
 
				+    material: str | None
			
 
				+    subtype: str | None
			
 
				+    color_name: str | None
			
 
				+    rgba: str | None
			
 
				+
			
 
				+    def to_dict(self) -> dict:
			
 
				+        return {
			
 
				+            "brand": self.brand,
			
 
				+            "material": self.material,
			
 
				+            "subtype": self.subtype,
			
 
				+            "color_name": self.color_name,
			
 
				+            "rgba": self.rgba,
			
 
				+        }
			
 
				+
			
 
				+
			
 
				+def _clean(value) -> str | None:
			
 
				+    """Trim a display field, collapsing blanks to None so the client can skip it."""
			
 
				+    text = str(value).strip() if value is not None else ""
			
 
				+    return text or None
			
 
				+
			
 
				+
			
 
				+def _identity_from_internal(spool) -> SlotSpoolIdentity:
			
 
				+    """Display identity from an internal-inventory ``Spool`` row."""
			
 
				+    return SlotSpoolIdentity(
			
 
				+        brand=_clean(spool.brand),
			
 
				+        material=_clean(spool.material),
			
 
				+        subtype=_clean(spool.subtype),
			
 
				+        color_name=_clean(spool.color_name),
			
 
				+        rgba=_clean(spool.rgba),
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+def _identity_from_spoolman(spool_dict: dict) -> SlotSpoolIdentity | None:
			
 
				+    """Display identity from a raw Spoolman spool dict, or None if unreadable.
			
 
				+
			
 
				+    Goes through ``_map_spoolman_spool`` rather than reading the dict directly:
			
 
				+    brand lives on the nested vendor, subtype is the filament name with its
			
 
				+    material prefix stripped, and ``color_name`` has a three-step read order
			
 
				+    Spoolman itself has no field for. Re-deriving any of that here is how the
			
 
				+    two modes would drift apart.
			
 
				+    """
			
 
				+    # Broad on purpose. This is a name for a dropdown, and the caller is on the
			
 
				+    # dispatch path -- ``compute_deficit_for_queue_item`` runs it before every
			
 
				+    # queue start. ``_map_spoolman_spool`` walks a dozen nested fields off the
			
 
				+    # wire (``filament.vendor.name``, ``extra.tag``, ``filament.color_hex``) and
			
 
				+    # any of them arriving as the wrong type raises AttributeError rather than
			
 
				+    # ValueError, so a narrow catch here would turn one malformed Spoolman
			
 
				+    # record into a failed dispatch. Losing the name costs a fallback to
			
 
				+    # telemetry, which is what every slot did before this existed.
			
 
				+    try:
			
 
				+        mapped = _map_spoolman_spool(spool_dict)
			
 
				+    except Exception as exc:  # noqa: BLE001 - display-only, must never block a dispatch
			
 
				+        logger.debug(
			
 
				+            "Spoolman spool %r has no usable display identity: %s",
			
 
				+            spool_dict.get("id") if isinstance(spool_dict, dict) else spool_dict,
			
 
				+            exc,
			
 
				+        )
			
 
				+        return None
			
 
				+    # Spoolman has no colour-name field, so `_map_spoolman_spool` synthesises
			
 
				+    # one from the subtype when nothing is stored -- which reads fine in an
			
 
				+    # inventory list ("PLA Basic") and badly as a colour ("Devil Design PLA
			
 
				+    # Basic (Basic)"). Drop it and let the client's catalogue lookup name the
			
 
				+    # hex, which is what an unnamed slot got before this existed.
			
 
				+    color_name = None if mapped.get("color_name_is_synthesized") else _clean(mapped.get("color_name"))
			
 
				+    return SlotSpoolIdentity(
			
 
				+        brand=_clean(mapped.get("brand")),
			
 
				+        material=_clean(mapped.get("material")),
			
 
				+        subtype=_clean(mapped.get("subtype")),
			
 
				+        color_name=color_name,
			
 
				+        rgba=_clean(mapped.get("rgba")),
			
 
				+    )
			
 
				+
			
 
				+
			
 
				 @dataclass(frozen=True)
			
 
				 class SlotMaterial:
			
 
				     """One inventory-bound AMS slot: what's in it, how much is left, which side."""
			
@@ -314,6 +424,9 @@ class SlotMaterial:
 
				     material_key: str
			
 
				     remaining_grams: float
			
 
				     extruder: int
			
 
				+    # Display-only; see SlotSpoolIdentity. None when the binding resolves to a
			
 
				+    # spool we cannot describe, which callers render from telemetry as before.
			
 
				+    spool: SlotSpoolIdentity | None = None
			
 
				 
			
 
				     def to_dict(self) -> dict:
			
 
				         return {
			
@@ -323,6 +436,7 @@ class SlotMaterial:
 
				             "material_key": self.material_key,
			
 
				             "remaining_g": self.remaining_grams,
			
 
				             "extruder": self.extruder,
			
 
				+            "spool": self.spool.to_dict() if self.spool else None,
			
 
				         }
			
 
				 
			
 
				 
			
@@ -344,7 +458,13 @@ async def build_slot_materials(db: AsyncSession, printer_id: int) -> list[SlotMa
 
				     _, ams_extruder_map, is_dual = await _get_printer_backup_context(printer_id)
			
 
				     materials: list[SlotMaterial] = []
			
 
				 
			
 
				-    def _append(ams_id: int, tray_id: int, material_key: str, remaining: float) -> None:
			
 
				+    def _append(
			
 
				+        ams_id: int,
			
 
				+        tray_id: int,
			
 
				+        material_key: str,
			
 
				+        remaining: float,
			
 
				+        spool: SlotSpoolIdentity | None = None,
			
 
				+    ) -> None:
			
 
				         materials.append(
			
 
				             SlotMaterial(
			
 
				                 ams_id=ams_id,
			
@@ -353,6 +473,7 @@ async def build_slot_materials(db: AsyncSession, printer_id: int) -> list[SlotMa
 
				                 material_key=material_key,
			
 
				                 remaining_grams=remaining,
			
 
				                 extruder=_extruder_side_for_ams(ams_id, ams_extruder_map, is_dual),
			
 
				+                spool=spool,
			
 
				             )
			
 
				         )
			
 
				 
			
@@ -391,7 +512,13 @@ async def build_slot_materials(db: AsyncSession, printer_id: int) -> list[SlotMa
 
				                     remaining = max(0.0, float(total) - float(used))
			
 
				             if remaining is None:
			
 
				                 continue
			
 
				-            _append(sa.ams_id, sa.tray_id, _material_identity_spoolman(spool_dict), remaining)
			
 
				+            _append(
			
 
				+                sa.ams_id,
			
 
				+                sa.tray_id,
			
 
				+                _material_identity_spoolman(spool_dict),
			
 
				+                remaining,
			
 
				+                _identity_from_spoolman(spool_dict),
			
 
				+            )
			
 
				         return materials
			
 
				 
			
 
				     internal_all = await db.execute(
			
@@ -412,6 +539,7 @@ async def build_slot_materials(db: AsyncSession, printer_id: int) -> list[SlotMa
 
				             assignment.tray_id,
			
 
				             _material_identity_internal(spool),
			
 
				             max(0.0, label_weight - weight_used),
			
 
				+            _identity_from_internal(spool),
			
 
				         )
			
 
				     return materials
			
 
				 
			
--- a/backend/app/services/firmware_update.py
+++ b/backend/app/services/firmware_update.py
@@ -344,6 +344,11 @@ class FirmwareUpdateService:
 
				                     progress_callback=on_upload_progress,
			
 
				                     socket_timeout=ftp_timeout,
			
 
				                     printer_model=model,
			
 
				+                    # Someone pressed "update firmware" and is watching a
			
 
				+                    # progress bar. Bounded and user-initiated, like a print
			
 
				+                    # dispatch, so it does not spend its retries on a cool-off
			
 
				+                    # meant for the background sweeps (#2898).
			
 
				+                    respect_handshake_cooloff=False,
			
 
				                     max_retries=ftp_retry_count,
			
 
				                     retry_delay=ftp_retry_delay,
			
 
				                     operation_name=f"Upload firmware to printer {printer_id}",
			
@@ -357,6 +362,7 @@ class FirmwareUpdateService:
 
				                     progress_callback=on_upload_progress,
			
 
				                     socket_timeout=ftp_timeout,
			
 
				                     printer_model=model,
			
 
				+                    respect_handshake_cooloff=False,
			
 
				                 )
			
 
				 
			
 
				             if not success:
			
--- a/backend/app/services/ftp_profiles.py
+++ b/backend/app/services/ftp_profiles.py
@@ -45,12 +45,27 @@ class FTPProfile:
 
				     # the printer). Capping to TLS 1.2 makes session resumption
			
 
				     # synchronous and the upload completes normally.
			
 
				     #
			
 
				-    # Note this cap only bites on models that *offer* 1.3 in the first
			
 
				-    # place. Probed directly on :990, an X1C and an H2D both refuse
			
 
				-    # TLS 1.0, 1.1 and 1.3 with a handshake_failure alert and complete
			
 
				-    # only on 1.2 — so for those models the cap is a no-op and the
			
 
				-    # negotiated version was never 1.3. The P2S evidently does offer
			
 
				-    # 1.3, which is why it alone surfaced the session-reuse bug.
			
 
				+    # This cap only bites on models that *offer* 1.3 in the first place,
			
 
				+    # and on the evidence so far none of them do. Probed directly on
			
 
				+    # :990, an X1C and an H2D refuse TLS 1.0, 1.1 and 1.3 and complete
			
 
				+    # only on 1.2; @grolmus then probed a 9-printer farm (#2780,
			
 
				+    # 2026-08-21) and got the same result on six P2S units, two X1C and
			
 
				+    # an H2D — tls1_3 refused, tls1_2 ok, every one. This comment used
			
 
				+    # to claim "the P2S evidently does offer 1.3"; six say otherwise.
			
 
				+    #
			
 
				+    # A cap is also not needed to reach a 1.2-only peer. Measured
			
 
				+    # against a local TLS-1.2-only server with the same context this
			
 
				+    # module builds: an uncapped client negotiates 1.2 and connects.
			
 
				+    # A client forced to 1.3 gets TLSV1_ALERT_PROTOCOL_VERSION — never
			
 
				+    # WRONG_VERSION_NUMBER, which comes from bytes that are not a TLS
			
 
				+    # record at all. See
			
 
				+    # ``tests/unit/services/test_cleartext_probe_2780.py``, which pins
			
 
				+    # both measurements so this comment stays falsifiable.
			
 
				+    #
			
 
				+    # So the entries below are kept as tuning slots and as a record of
			
 
				+    # what each reporter saw, not because the mechanism is understood.
			
 
				+    # Two of the three explain a symptom this cap cannot affect; see
			
 
				+    # their own comments.
			
 
				     # (P1S untested; no claim made either way.)
			
 
				     #
			
 
				     # **Defaults to False** — only applied to printer models where a
			
@@ -72,35 +87,53 @@ DEFAULT_PROFILE = FTPProfile()
 
				 # AFTER alias normalisation, so internal SSDP codes ("N7") resolve via
			
 
				 # ``_MODEL_ALIASES`` below.
			
 
				 _PROFILES: dict[str, FTPProfile] = {
			
 
				-    # P2S firmware 01.02.00.00 trips the vsFTPd + TLS 1.3 session-reuse
			
 
				-    # bug on the FTPS data channel (#1401, reporter @iitazz). Cap to
			
 
				-    # TLS 1.2 so session resumption is synchronous and the upload
			
 
				-    # completes.
			
 
				+    # P2S firmware 01.02.00.00 (#1401, reporter @iitazz). Symptom is a
			
 
				+    # 426 truncation part-way through a transfer, on the data channel —
			
 
				+    # a different failure from the handshake ones below, and the only
			
 
				+    # one here whose mechanism a TLS-1.3 session-ticket problem could
			
 
				+    # actually explain. The reporter confirmed the fix.
			
 
				+    #
			
 
				+    # Unresolved: @grolmus's six P2S units refuse TLS 1.3 outright
			
 
				+    # (#2780), so on their firmware the negotiated version was already
			
 
				+    # 1.2 and this cap changes nothing. Either the firmware moved
			
 
				+    # between the two reports, or #1401 was fixed by something else in
			
 
				+    # the same change. Kept because a reporter confirmed it and no one
			
 
				+    # has hardware to re-test it on.
			
 
				     "P2S": FTPProfile(
			
 
				         cap_tls_v1_2=True,
			
 
				     ),
			
 
				     # X2D firmware 01.01.00.00 fails the implicit-FTPS handshake on
			
 
				-    # port 990 with ``[SSL: WRONG_VERSION_NUMBER]`` against Python
			
 
				-    # 3.13's default TLS-1.3 ClientHello (#1638, reporter @vasmarfas).
			
 
				-    # Without the 3MF download the print falls through to the no-3MF
			
 
				-    # fallback archive path and the card lands almost empty (no
			
 
				-    # filament total, no layers, no MakerWorld link). Cap to TLS 1.2
			
 
				-    # by analogy with P2S; if the symptom turns out to be a different
			
 
				-    # FTPS variant on the X2D (explicit AUTH TLS, different port) the
			
 
				-    # entry stays useful as a per-model tuning slot for the follow-up.
			
 
				+    # port 990 with ``[SSL: WRONG_VERSION_NUMBER]`` (#1638, reporter
			
 
				+    # @vasmarfas). Without the 3MF download the print falls through to
			
 
				+    # the no-3MF fallback archive path and the card lands almost empty
			
 
				+    # (no filament total, no layers, no MakerWorld link).
			
 
				+    #
			
 
				+    # RE-TEST WANTED. This was capped on the reading that the error came
			
 
				+    # from "Python 3.13's default TLS-1.3 ClientHello". That reading is
			
 
				+    # now measured wrong: WRONG_VERSION_NUMBER is what a *non-TLS*
			
 
				+    # answer produces, a version mismatch reports itself differently,
			
 
				+    # and an uncapped client reaches a 1.2-only peer unaided (#2780).
			
 
				+    # So this cap cannot be what changed the outcome, and the X2D is
			
 
				+    # most likely answering :990 with something that is not TLS — the
			
 
				+    # cleartext probe in ``bambu_ftp`` will now say what. Left in place
			
 
				+    # rather than removed: nobody here has an X2D, and the entry costs
			
 
				+    # nothing on a printer that does not offer 1.3 anyway.
			
 
				     "X2D": FTPProfile(
			
 
				         cap_tls_v1_2=True,
			
 
				     ),
			
 
				-    # H2C firmware 01.02.00.00 (#2582, reporter @gyrene2083) — same H2
			
 
				-    # generation and same firmware line as P2S, and with no profile it
			
 
				-    # ran on the Python-default TLS 1.3. Reported symptom is exactly the
			
 
				-    # one the X2D comment describes: the sliced 3MF intermittently fails
			
 
				-    # to come off the printer over FTPS, so the print drops to the no-3MF
			
 
				-    # fallback archive with no slice data — which is why the Print Log
			
 
				-    # shows no filament and nothing is deducted. Cap to TLS 1.2 by analogy
			
 
				-    # with P2S (intermittent "sometimes works" points at the session-reuse
			
 
				-    # variant, not X2D's deterministic handshake failure); if a debug
			
 
				-    # capture shows a different FTPS variant the entry stays the tuning slot.
			
 
				+    # H2C firmware 01.02.00.00 (#2582, reporter @gyrene2083). The sliced
			
 
				+    # 3MF intermittently fails to come off the printer over FTPS, so the
			
 
				+    # print drops to the no-3MF fallback archive with no slice data —
			
 
				+    # which is why the Print Log shows no filament and nothing is
			
 
				+    # deducted.
			
 
				+    #
			
 
				+    # RE-TEST WANTED, same reasoning as the X2D above. Capped "by
			
 
				+    # analogy with P2S" on the belief that the profile-less path "ran on
			
 
				+    # the Python-default TLS 1.3"; measurement says a 1.2-only peer
			
 
				+    # negotiates 1.2 without a cap, so there was no 1.3 to fall back
			
 
				+    # from (#2780). "Intermittent" now points somewhere better: it is
			
 
				+    # the signature of the transient non-TLS refusal @grolmus sees on
			
 
				+    # his P2S units, which is the same H2 firmware line.
			
 
				     "H2C": FTPProfile(
			
 
				         cap_tls_v1_2=True,
			
 
				     ),
			
--- a/backend/app/services/ha_sensor_manager.py
+++ b/backend/app/services/ha_sensor_manager.py
@@ -18,12 +18,13 @@ door contact that stops responding must not strand the queue.
 
				 import asyncio
			
 
				 import logging
			
 
				 from dataclasses import dataclass
			
 
				+from typing import Protocol
			
 
				 
			
 
				 from sqlalchemy import select
			
 
				 from sqlalchemy.ext.asyncio import AsyncSession
			
 
				 
			
 
				 from backend.app.models.printer import Printer
			
 
				-from backend.app.models.printer_ha_sensor import PrinterHASensor
			
 
				+from backend.app.models.printer_ha_sensor import LAST_STATE_MAX_LENGTH, PrinterHASensor
			
 
				 from backend.app.services.homeassistant import as_float, homeassistant_service
			
 
				 from backend.app.utils.local_time import utcnow_naive
			
 
				 
			
@@ -44,6 +45,25 @@ class SensorReading:
 
				     reachable: bool
			
 
				 
			
 
				 
			
 
				+def persistable_state(state: str | None, max_length: int) -> str | None:
			
 
				+    """Fit a raw HA state into a last_state column.
			
 
				+
			
 
				+    A numeric entity can start reporting free text (an enum, an error string)
			
 
				+    longer than the column. PostgreSQL rejects the oversized row, and since a
			
 
				+    poll pass commits every sensor at once, one such entity would sink every
			
 
				+    other sensor's update on every tick -- and for printer sensors that also
			
 
				+    freezes the print interlock's view of the world.
			
 
				+
			
 
				+    The cached SensorReading keeps the full state; only what is persisted is
			
 
				+    cut, and the comparison against the stored value is done on the cut form so
			
 
				+    an unchanged-but-long state does not read as a change on every poll.
			
 
				+
			
 
				+    Shared with the storage-location poller, which has the same column on its
			
 
				+    own table -- each caller passes its own model's width.
			
 
				+    """
			
 
				+    return state[:max_length] if state else state
			
 
				+
			
 
				+
			
 
				 class HASensorManager:
			
 
				     def __init__(self):
			
 
				         self._task: asyncio.Task | None = None
			
@@ -162,8 +182,9 @@ class HASensorManager:
 
				             self._last_alerting[sensor.id] = reading.alerting
			
 
				 
			
 
				         sensor.last_checked = utcnow_naive()
			
 
				-        if reading.reachable and sensor.last_state != reading.state:
			
 
				-            sensor.last_state = reading.state
			
 
				+        persisted = persistable_state(reading.state, LAST_STATE_MAX_LENGTH)
			
 
				+        if reading.reachable and sensor.last_state != persisted:
			
 
				+            sensor.last_state = persisted
			
 
				             sensor.last_changed = sensor.last_checked
			
 
				         await db.commit()
			
 
				         await db.refresh(sensor)
			
@@ -196,8 +217,9 @@ class HASensorManager:
 
				 
			
 
				             sensor.last_checked = now
			
 
				             if reading.reachable:
			
 
				-                if sensor.last_state != reading.state:
			
 
				-                    sensor.last_state = reading.state
			
 
				+                persisted = persistable_state(reading.state, LAST_STATE_MAX_LENGTH)
			
 
				+                if sensor.last_state != persisted:
			
 
				+                    sensor.last_state = persisted
			
 
				                     sensor.last_changed = now
			
 
				 
			
 
				             # Notify on the edge into alerting only. `was_alerting is None` is
			
@@ -228,7 +250,25 @@ class HASensorManager:
 
				                 logger.warning("Failed to send HA sensor alert for '%s': %s", sensor.name, e)
			
 
				 
			
 
				 
			
 
				-def evaluate(sensor: PrinterHASensor, payload: dict | None) -> SensorReading:
			
 
				+class _AlertableSensor(Protocol):
			
 
				+    """Structural type for evaluate()/describe_state().
			
 
				+
			
 
				+    PrinterHASensor and LocationHASensor are unrelated SQLAlchemy models —
			
 
				+    one has no base class in common with the other beyond ``Base`` — but both
			
 
				+    carry these five fields with the same meaning, and location_ha_sensor_
			
 
				+    manager.py imports these two functions to reuse the exact same alert
			
 
				+    logic rather than reimplementing it. A concrete PrinterHASensor
			
 
				+    annotation here would be a lie for half of the actual callers.
			
 
				+    """
			
 
				+
			
 
				+    kind: str
			
 
				+    unit: str | None
			
 
				+    alert_state: str | None
			
 
				+    alert_above: float | None
			
 
				+    alert_below: float | None
			
 
				+
			
 
				+
			
 
				+def evaluate(sensor: _AlertableSensor, payload: dict | None) -> SensorReading:
			
 
				     """Turn one HA state payload into a reading.
			
 
				 
			
 
				     Split out from the manager so the alert rules can be tested without a
			
@@ -261,7 +301,7 @@ def evaluate(sensor: PrinterHASensor, payload: dict | None) -> SensorReading:
 
				     return SensorReading(state=normalized, value=None, alerting=alerting, reachable=True)
			
 
				 
			
 
				 
			
 
				-def describe_state(sensor: PrinterHASensor, reading: SensorReading) -> str:
			
 
				+def describe_state(sensor: _AlertableSensor, reading: SensorReading) -> str:
			
 
				     """Human-readable state for a notification body ("open", "31.4 °C")."""
			
 
				     if sensor.kind == "numeric" and reading.value is not None:
			
 
				         return f"{reading.value:g} {sensor.unit}".strip() if sensor.unit else f"{reading.value:g}"
			
--- a/backend/app/services/hms_errors.py
+++ b/backend/app/services/hms_errors.py
@@ -873,3 +873,48 @@ def get_error_description(error_code: str) -> str | None:
 
				         Human-readable description or None if not found
			
 
				     """
			
 
				     return HMS_ERROR_DESCRIPTIONS.get(error_code.upper())
			
 
				+
			
 
				+
			
 
				+def describe_fault(full_code: str | None) -> str | None:
			
 
				+    """Resolve a fault's description from the canonical `full_code`.
			
 
				+
			
 
				+    `full_code` is the identifier the firmware itself matches on: 8 hex chars
			
 
				+    for a 32-bit `print_error`, 16 for a 64-bit `hms[]` entry. This is the one
			
 
				+    place that maps either shape onto this table, so every surface that reports
			
 
				+    a fault says the same thing about it.
			
 
				+
			
 
				+    An 8-char code is this table's `MMMM_EEEE` key with the separator removed --
			
 
				+    the parser derives `full_code` and that key from the same 32-bit value -- so
			
 
				+    it resolves exactly.
			
 
				+
			
 
				+    A 16-char code is tried whole first, then collapsed to `G1_G4` (the first
			
 
				+    and last of its four hex groups). That collapse is lossy and not injective:
			
 
				+    it discards the Part No. and Alert level groups, and #2728 measured 65
			
 
				+    documented faults falling onto `0300_0001` alone, so a hit can in principle
			
 
				+    attribute a neighbouring fault's sentence to this one. It is kept because it
			
 
				+    is what this codebase has always done -- the notification path, the queue's
			
 
				+    failure-reason helper and the frontend modal all resolve `hms[]` faults this
			
 
				+    way, and it does resolve real ones (a `0500_4038` nozzle mismatch arrives in
			
 
				+    that shape). Refusing to collapse would not be a stricter reading of the
			
 
				+    same data; it would silently stop describing faults that are described
			
 
				+    today, and leave this field null while the UI shows text for the same fault.
			
 
				+    Narrowing it is #2728's subject, and belongs there where the key spaces can
			
 
				+    be changed together.
			
 
				+
			
 
				+    Returns None for an empty, malformed, or unknown code.
			
 
				+    """
			
 
				+    if not full_code:
			
 
				+        return None
			
 
				+    code = full_code.strip().upper()
			
 
				+    if len(code) == 8:
			
 
				+        return HMS_ERROR_DESCRIPTIONS.get(f"{code[:4]}_{code[4:]}")
			
 
				+    if len(code) == 16:
			
 
				+        # `is not None` rather than truthiness: an entry whose text is empty is
			
 
				+        # still an entry, and falling through on it would resolve the fault to a
			
 
				+        # neighbour's sentence. No blank values ship today; the frontend lookup
			
 
				+        # draws the same distinction and a regenerated catalogue could.
			
 
				+        exact = HMS_ERROR_DESCRIPTIONS.get(code)
			
 
				+        if exact is not None:
			
 
				+            return exact
			
 
				+        return HMS_ERROR_DESCRIPTIONS.get(f"{code[:4]}_{code[12:]}")
			
 
				+    return None
			
--- a/backend/app/services/inventory_mode.py
+++ b/backend/app/services/inventory_mode.py
@@ -0,0 +1,42 @@
 
				+"""Which table holds a printer's slot assignments.
			
 
				+
			
 
				+Bambuddy keeps AMS slot assignments in two places: ``spool_assignment`` for the
			
 
				+built-in inventory and ``spoolman_slot_assignments`` for Spoolman. Exactly one
			
 
				+of them describes reality at any moment, and which one is a user setting.
			
 
				+
			
 
				+Until #2812 the two were kept from overlapping by emptying the inactive table
			
 
				+whenever the mode toggled, which made merely looking at the other mode destroy
			
 
				+the configuration you had. Nothing is deleted now, so both tables can hold rows
			
 
				+at once and every reader has to say which one it means.
			
 
				+
			
 
				+This is deliberately a module of its own rather than a helper on the settings
			
 
				+routes: the readers are services, and importing an API route module from a
			
 
				+service to answer a one-key question invites an import cycle. Several call
			
 
				+sites already carry their own private copy of this predicate for that reason
			
 
				+(``filament_deficit``, ``print_scheduler``, ``inventory``); those are unchanged
			
 
				+and correct, and are only worth folding in here if they are touched anyway.
			
 
				+"""
			
 
				+
			
 
				+import logging
			
 
				+
			
 
				+from sqlalchemy.ext.asyncio import AsyncSession
			
 
				+
			
 
				+logger = logging.getLogger(__name__)
			
 
				+
			
 
				+
			
 
				+async def spoolman_owns_assignments(db: AsyncSession) -> bool:
			
 
				+    """True when ``spoolman_slot_assignments`` is the table that counts.
			
 
				+
			
 
				+    Fails closed to the built-in inventory: a setting that cannot be read is
			
 
				+    not evidence that the user switched modes, and treating an unreadable
			
 
				+    setting as "Spoolman" would make a built-in install look as though every
			
 
				+    tray were unassigned.
			
 
				+    """
			
 
				+    try:
			
 
				+        from backend.app.api.routes.settings import get_setting
			
 
				+
			
 
				+        value = await get_setting(db, "spoolman_enabled")
			
 
				+        return bool(value) and value.lower() == "true"
			
 
				+    except Exception as exc:  # noqa: BLE001 — a mode probe must not raise into its callers
			
 
				+        logger.debug("Could not read spoolman_enabled, assuming built-in inventory: %s", exc)
			
 
				+        return False
			
--- a/backend/app/services/label_renderer.py
+++ b/backend/app/services/label_renderer.py
@@ -154,24 +154,28 @@ def _qr_png_bytes(payload: str, *, box_size: int = 4, border: int = 2) -> bytes:
 
				 def _draw_swatch(c: rl_canvas.Canvas, x: float, y: float, w: float, h: float, data: LabelData) -> None:
			
 
				     """Draw the colour swatch. Multi-colour spools use vertical stripes
			
 
				     (matching the FilamentSwatch convention in the frontend)."""
			
 
				-    primary = _color_from_hex(data.rgba)
			
 
				-    extras = [_color_from_hex(h) for h in (data.extra_colors or []) if h]
			
 
				-    colors = [primary, *extras]
			
 
				+    c.saveState()
			
 
				+    try:
			
 
				+        primary = _color_from_hex(data.rgba)
			
 
				+        extras = [_color_from_hex(h) for h in (data.extra_colors or []) if h]
			
 
				+        colors = [primary, *extras]
			
 
				 
			
 
				-    if not colors:
			
 
				-        c.setFillColor(HexColor(0x808080))
			
 
				-        c.rect(x, y, w, h, stroke=0, fill=1)
			
 
				-        return
			
 
				+        if not colors:
			
 
				+            c.setFillColor(HexColor(0x808080))
			
 
				+            c.rect(x, y, w, h, stroke=0, fill=1)
			
 
				+            return
			
 
				 
			
 
				-    stripe_w = w / len(colors)
			
 
				-    for i, col in enumerate(colors):
			
 
				-        c.setFillColor(col)
			
 
				-        c.rect(x + i * stripe_w, y, stripe_w, h, stroke=0, fill=1)
			
 
				+        stripe_w = w / len(colors)
			
 
				+        for i, col in enumerate(colors):
			
 
				+            c.setFillColor(col)
			
 
				+            c.rect(x + i * stripe_w, y, stripe_w, h, stroke=0, fill=1)
			
 
				 
			
 
				-    # Thin black border so light-colour swatches stay visible on white labels.
			
 
				-    c.setStrokeColor(black)
			
 
				-    c.setLineWidth(0.3)
			
 
				-    c.rect(x, y, w, h, stroke=1, fill=0)
			
 
				+        # Thin black border so light-colour swatches stay visible on white labels.
			
 
				+        c.setStrokeColor(black)
			
 
				+        c.setLineWidth(0.3)
			
 
				+        c.rect(x, y, w, h, stroke=1, fill=0)
			
 
				+    finally:
			
 
				+        c.restoreState()
			
 
				 
			
 
				 
			
 
				 def _roomy_qr_size(inner_w: float, inner_h: float) -> float:
			
@@ -442,7 +446,20 @@ def _render_single_label_pdf(template: TemplateName, data_list: list[LabelData],
 
				     return buf.getvalue()
			
 
				 
			
 
				 
			
 
				-def _render_sheet_pdf(template: TemplateName, data_list: list[LabelData], monochrome: bool = False) -> bytes:
			
 
				+def get_sheet_capacity(template: TemplateName) -> int | None:
			
 
				+    """Return the number of slots on a sheet template, or ``None`` for roll labels."""
			
 
				+    layout = _SHEET_TEMPLATES.get(template)
			
 
				+    if layout is None:
			
 
				+        return None
			
 
				+    return layout[3] * layout[4]
			
 
				+
			
 
				+
			
 
				+def _render_sheet_pdf(
			
 
				+    template: TemplateName,
			
 
				+    data_list: list[LabelData],
			
 
				+    monochrome: bool,
			
 
				+    starting_position: int,
			
 
				+) -> bytes:
			
 
				     page_size, w_mm, h_mm, cols, rows, top_mm, left_mm, col_gap_mm, row_gap_mm = _SHEET_TEMPLATES[template]
			
 
				     page_w, page_h = page_size
			
 
				 
			
@@ -458,21 +475,37 @@ def _render_sheet_pdf(template: TemplateName, data_list: list[LabelData], monoch
 
				     c.setTitle(f"Bambuddy spool labels ({template})")
			
 
				 
			
 
				     per_page = cols * rows
			
 
				-    for page_start in range(0, len(data_list), per_page):
			
 
				-        chunk = data_list[page_start : page_start + per_page]
			
 
				+    if starting_position < 1 or starting_position > per_page:
			
 
				+        raise ValueError(f"Starting position must be between 1 and {per_page} for {template}")
			
 
				+
			
 
				+    data_index = 0
			
 
				+    page_number = 0
			
 
				+    while data_index < len(data_list):
			
 
				+        slot_offset = starting_position - 1 if page_number == 0 else 0
			
 
				+        page_capacity = per_page - slot_offset
			
 
				+        chunk = data_list[data_index : data_index + page_capacity]
			
 
				         for idx, data in enumerate(chunk):
			
 
				-            row = idx // cols
			
 
				-            col = idx % cols
			
 
				+            slot_index = slot_offset + idx
			
 
				+            row = slot_index // cols
			
 
				+            col = slot_index % cols
			
 
				             x = left_margin + col * (label_w + col_gap)
			
 
				             y = page_h - top_margin - (row + 1) * label_h - row * row_gap
			
 
				             _draw_label(c, x, y, label_w, label_h, data, monochrome)
			
 
				         c.showPage()
			
 
				+        data_index += len(chunk)
			
 
				+        page_number += 1
			
 
				 
			
 
				     c.save()
			
 
				     return buf.getvalue()
			
 
				 
			
 
				 
			
 
				-def render_labels(template: TemplateName, data_list: list[LabelData], *, monochrome: bool = False) -> bytes:
			
 
				+def render_labels(
			
 
				+    template: TemplateName,
			
 
				+    data_list: list[LabelData],
			
 
				+    *,
			
 
				+    monochrome: bool = False,
			
 
				+    starting_position: int = 1,
			
 
				+) -> bytes:
			
 
				     """Render ``data_list`` to a PDF using the named template. Returns bytes.
			
 
				 
			
 
				     Empty ``data_list`` still produces a valid (empty) PDF — callers should
			
@@ -481,14 +514,19 @@ def render_labels(template: TemplateName, data_list: list[LabelData], *, monochr
 
				     ``monochrome`` drops the colour swatch (which prints as a useless grey block
			
 
				     on black-and-white thermal printers) and reclaims the space for text; the
			
 
				     hex-code line still carries the colour. See #1870.
			
 
				+
			
 
				+    ``starting_position`` is one-based and applies only to the first page of a
			
 
				+    sheet template. Later pages always begin at the first slot.
			
 
				     """
			
 
				     if template in _SINGLE_LABEL_SIZES_MM:
			
 
				+        if starting_position != 1:
			
 
				+            raise ValueError("Starting position is only supported for sheet label templates")
			
 
				         return _render_single_label_pdf(template, data_list, monochrome)
			
 
				     if template in _SHEET_TEMPLATES:
			
 
				-        return _render_sheet_pdf(template, data_list, monochrome)
			
 
				+        return _render_sheet_pdf(template, data_list, monochrome, starting_position)
			
 
				     raise ValueError(f"Unknown label template: {template!r}")
			
 
				 
			
 
				 
			
 
				-__all__ = ["LabelData", "TemplateName", "render_labels"]
			
 
				+__all__ = ["LabelData", "TemplateName", "get_sheet_capacity", "render_labels"]
			
 
				 # white re-exported for completeness; future templates may need a paper-tone variant.
			
 
				 _ = white
			
--- a/backend/app/services/layer_timelapse.py
+++ b/backend/app/services/layer_timelapse.py
@@ -14,6 +14,7 @@ from pathlib import Path
 
				 from backend.app.core.config import settings
			
 
				 from backend.app.services.camera import apply_camera_rotation
			
 
				 from backend.app.services.external_camera import capture_frame
			
 
				+from backend.app.utils.ffmpeg_output import NO_FFMPEG_OUTPUT, summarize_ffmpeg_stderr
			
 
				 
			
 
				 logger = logging.getLogger(__name__)
			
 
				 
			
@@ -189,7 +190,7 @@ class TimelapseSession:
 
				             stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=300)
			
 
				 
			
 
				             if process.returncode != 0:
			
 
				-                logger.error("ffmpeg timelapse stitch failed: %s", stderr.decode()[:500])
			
 
				+                logger.error("ffmpeg timelapse stitch failed: %s", summarize_ffmpeg_stderr(stderr) or NO_FFMPEG_OUTPUT)
			
 
				                 return False
			
 
				 
			
 
				             logger.info("Created timelapse video: %s (%s frames)", output_path, self.frame_count)
			
--- a/backend/app/services/location_ha_sensor_manager.py
+++ b/backend/app/services/location_ha_sensor_manager.py
@@ -0,0 +1,216 @@
 
				+import asyncio
			
 
				+import logging
			
 
				+
			
 
				+from sqlalchemy import select
			
 
				+from sqlalchemy.ext.asyncio import AsyncSession
			
 
				+
			
 
				+from backend.app.models.location import Location
			
 
				+from backend.app.models.location_ha_sensor import LAST_STATE_MAX_LENGTH, LocationHASensor
			
 
				+from backend.app.models.settings import Settings
			
 
				+from backend.app.services.ha_sensor_manager import SensorReading, describe_state, evaluate, persistable_state
			
 
				+from backend.app.services.homeassistant import homeassistant_service
			
 
				+from backend.app.utils.local_time import utcnow_naive
			
 
				+
			
 
				+logger = logging.getLogger(__name__)
			
 
				+
			
 
				+POLL_INTERVAL = 120
			
 
				+MIN_POLL_INTERVAL = 60
			
 
				+
			
 
				+
			
 
				+class LocationHASensorManager:
			
 
				+    def __init__(self):
			
 
				+        self._task: asyncio.Task | None = None
			
 
				+        # sensor id -> last reading. Sensors absent from this map have not been
			
 
				+        # polled yet; callers must not read that as "not alerting" without also
			
 
				+        # checking, which is why get_reading returns None rather than a default.
			
 
				+        self._readings: dict[int, SensorReading] = {}
			
 
				+        # sensor id -> alerting, from the last reading we could actually take.
			
 
				+        # Kept apart from _readings because a dropout must not read as the
			
 
				+        # alert clearing: on -> unavailable -> on is one continuous alert, and
			
 
				+        # notifying off _readings alone would ping the user on every reconnect
			
 
				+        # of a flaky sensor. Absent means "never had a reachable reading".
			
 
				+        self._last_alerting: dict[int, bool] = {}
			
 
				+
			
 
				+    def start(self):
			
 
				+        if self._task is None:
			
 
				+            self._task = asyncio.create_task(self._poll_loop())
			
 
				+            logger.info("Home Assistant location-sensor poller started")
			
 
				+
			
 
				+    def stop(self):
			
 
				+        if self._task:
			
 
				+            self._task.cancel()
			
 
				+            self._task = None
			
 
				+            logger.info("Home Assistant location-sensor poller stopped")
			
 
				+
			
 
				+    def get_reading(self, sensor_id: int) -> SensorReading | None:
			
 
				+        return self._readings.get(sensor_id)
			
 
				+
			
 
				+    def forget(self, sensor_id: int):
			
 
				+        """Drop a deleted sensor's cached reading so its id cannot be reused
			
 
				+        by a later row and answer with the old sensor's state."""
			
 
				+        self._readings.pop(sensor_id, None)
			
 
				+        self._last_alerting.pop(sensor_id, None)
			
 
				+
			
 
				+    async def _poll_loop(self):
			
 
				+        # Poll first, sleep after — the interval is configurable and can be
			
 
				+        # minutes long, and a restart should not leave every location's
			
 
				+        # reading blank on the card for a full interval before the first one
			
 
				+        # lands.
			
 
				+        while True:
			
 
				+            try:
			
 
				+                await self.poll_once()
			
 
				+            except asyncio.CancelledError:
			
 
				+                break
			
 
				+            except Exception as e:
			
 
				+                logger.warning("Home Assistant location-sensor poll failed: %s", e)
			
 
				+            try:
			
 
				+                await asyncio.sleep(await self._get_poll_interval())
			
 
				+            except asyncio.CancelledError:
			
 
				+                break
			
 
				+            except Exception as e:
			
 
				+                # _get_poll_interval() reads Settings, so this leg does I/O
			
 
				+                # and a transient database failure (pool exhaustion, a
			
 
				+                # restarting server) can raise here. Letting it escape ends
			
 
				+                # the task for good: stop() is what clears self._task, so a
			
 
				+                # loop that died on its own leaves it set and start() will
			
 
				+                # not revive it — location sensors would stay frozen until
			
 
				+                # the process restarts. The poll_once() call above already
			
 
				+                # survives the same error one line earlier.
			
 
				+                logger.warning("Home Assistant location-sensor poll interval lookup failed: %s", e)
			
 
				+                await asyncio.sleep(POLL_INTERVAL)
			
 
				+
			
 
				+    async def _get_poll_interval(self) -> int:
			
 
				+        """User-configurable poll cadence, clamped to a sane floor.
			
 
				+
			
 
				+        Falls back to the default on a missing row or a corrupted value
			
 
				+        rather than raising — a bad setting must not take the poller down.
			
 
				+        """
			
 
				+        from backend.app.core.database import async_session
			
 
				+
			
 
				+        async with async_session() as db:
			
 
				+            result = await db.execute(select(Settings).where(Settings.key == "location_sensor_poll_interval"))
			
 
				+            row = result.scalar_one_or_none()
			
 
				+        if row is None:
			
 
				+            return POLL_INTERVAL
			
 
				+        try:
			
 
				+            return max(MIN_POLL_INTERVAL, int(row.value))
			
 
				+        except (TypeError, ValueError):
			
 
				+            return POLL_INTERVAL
			
 
				+
			
 
				+    async def poll_once(self):
			
 
				+        """One pass over every configured sensor."""
			
 
				+        from backend.app.core.database import async_session
			
 
				+
			
 
				+        async with async_session() as db:
			
 
				+            result = await db.execute(select(LocationHASensor))
			
 
				+            sensors = list(result.scalars().all())
			
 
				+
			
 
				+            # Drop readings for rows that no longer exist. The delete route
			
 
				+            # calls forget(), but a location deleted with sensors attached
			
 
				+            # takes them out by cascade, and a restored backup can renumber
			
 
				+            # them — either way a stale id must not answer for a later sensor.
			
 
				+            live = {s.id for s in sensors}
			
 
				+            for stale in set(self._readings) - live:
			
 
				+                self.forget(stale)
			
 
				+
			
 
				+            if not sensors:
			
 
				+                return
			
 
				+
			
 
				+            if not await self._configure(db):
			
 
				+                for sensor in sensors:
			
 
				+                    self._readings[sensor.id] = SensorReading(None, None, False, False)
			
 
				+                return
			
 
				+
			
 
				+            states = await homeassistant_service.fetch_states(sorted({s.entity_id for s in sensors}))
			
 
				+            await self._apply(db, sensors, states)
			
 
				+
			
 
				+    async def refresh_one(self, db: AsyncSession, sensor: LocationHASensor):
			
 
				+        """Read a single sensor now, on the caller's session.
			
 
				+
			
 
				+        Used after a create or an edit so the card shows a state straight away
			
 
				+        instead of blank until the next tick. Deliberately not a full
			
 
				+        ``poll_once``: a request handler must not wait on every configured
			
 
				+        entity, and must not fire another user's notification as a side effect
			
 
				+        of this one saving a form.
			
 
				+        """
			
 
				+        self.forget(sensor.id)
			
 
				+        if not await self._configure(db):
			
 
				+            self._readings[sensor.id] = SensorReading(None, None, False, False)
			
 
				+            return
			
 
				+
			
 
				+        states = await homeassistant_service.fetch_states([sensor.entity_id])
			
 
				+        reading = evaluate(sensor, states.get(sensor.entity_id))
			
 
				+        self._readings[sensor.id] = reading
			
 
				+        if reading.reachable:
			
 
				+            self._last_alerting[sensor.id] = reading.alerting
			
 
				+
			
 
				+        sensor.last_checked = utcnow_naive()
			
 
				+        persisted = persistable_state(reading.state, LAST_STATE_MAX_LENGTH)
			
 
				+        if reading.reachable and sensor.last_state != persisted:
			
 
				+            sensor.last_state = persisted
			
 
				+            sensor.last_changed = sensor.last_checked
			
 
				+        await db.commit()
			
 
				+        await db.refresh(sensor)
			
 
				+
			
 
				+    async def _configure(self, db: AsyncSession) -> bool:
			
 
				+        from backend.app.api.routes.settings import get_homeassistant_settings
			
 
				+
			
 
				+        try:
			
 
				+            ha_settings = await get_homeassistant_settings(db)
			
 
				+        except Exception as e:
			
 
				+            logger.warning("Failed to read Home Assistant settings: %s", e)
			
 
				+            return False
			
 
				+        if not ha_settings["ha_url"] or not ha_settings["ha_token"]:
			
 
				+            return False
			
 
				+        homeassistant_service.configure(ha_settings["ha_url"], ha_settings["ha_token"])
			
 
				+        return True
			
 
				+
			
 
				+    async def _apply(self, db: AsyncSession, sensors: list[LocationHASensor], states: dict[str, dict | None]):
			
 
				+        """Fold poll results into the cache, the DB and any notifications."""
			
 
				+        from backend.app.services.notification_service import notification_service
			
 
				+
			
 
				+        now = utcnow_naive()
			
 
				+        alerts: list[tuple[LocationHASensor, SensorReading]] = []
			
 
				+
			
 
				+        for sensor in sensors:
			
 
				+            payload = states.get(sensor.entity_id)
			
 
				+            reading = evaluate(sensor, payload)
			
 
				+            was_alerting = self._last_alerting.get(sensor.id)
			
 
				+            self._readings[sensor.id] = reading
			
 
				+
			
 
				+            sensor.last_checked = now
			
 
				+            if reading.reachable:
			
 
				+                persisted = persistable_state(reading.state, LAST_STATE_MAX_LENGTH)
			
 
				+                if sensor.last_state != persisted:
			
 
				+                    sensor.last_state = persisted
			
 
				+                    sensor.last_changed = now
			
 
				+
			
 
				+            # Notify on the edge into alerting only. `was_alerting is None` is
			
 
				+            # a cold cache (first poll after a restart) — a drybox that was
			
 
				+            # already too humid then has not just become too humid, and
			
 
				+            # re-announcing it on every restart would train users to ignore
			
 
				+            # the alert.
			
 
				+            if sensor.notify_on_alert and reading.reachable and reading.alerting and was_alerting is False:
			
 
				+                alerts.append((sensor, reading))
			
 
				+
			
 
				+            if reading.reachable:
			
 
				+                self._last_alerting[sensor.id] = reading.alerting
			
 
				+
			
 
				+        await db.commit()
			
 
				+
			
 
				+        for sensor, reading in alerts:
			
 
				+            # db.get, not sensor.location: touching the lazy relationship from
			
 
				+            # an async session raises MissingGreenlet.
			
 
				+            location = await db.get(Location, sensor.location_id)
			
 
				+            try:
			
 
				+                await notification_service.on_location_ha_sensor_alert(
			
 
				+                    location_name=location.name if location else "Unknown",
			
 
				+                    sensor_name=sensor.name,
			
 
				+                    state=describe_state(sensor, reading),
			
 
				+                    db=db,
			
 
				+                )
			
 
				+            except Exception as e:
			
 
				+                logger.warning("Failed to send HA sensor alert for '%s': %s", sensor.name, e)
			
 
				+
			
 
				+
			
 
				+location_ha_sensor_manager = LocationHASensorManager()
			
--- a/backend/app/services/location_service.py
+++ b/backend/app/services/location_service.py
@@ -3,6 +3,7 @@
 
				 from __future__ import annotations
			
 
				 
			
 
				 import logging
			
 
				+import re
			
 
				 import time
			
 
				 from dataclasses import dataclass
			
 
				 
			
@@ -18,6 +19,24 @@ logger = logging.getLogger(__name__)
 
				 
			
 
				 DUPLICATE_LOCATION_NAME = "A location with this name already exists"
			
 
				 
			
 
				+# AMS residency markers, not storage locations. Bambuddy used to write the slot
			
 
				+# a spool was loaded into -- "<printer> - AMS A1", the shape
			
 
				+# `SpoolmanClient.convert_ams_slot_to_location` still produces -- straight into
			
 
				+# Spoolman's `location` field. That writer went away when Storage Location
			
 
				+# became a place the user chooses (#1114), but the strings survive on people's
			
 
				+# Spoolman spools, and importing them offers a printer slot as somewhere to put
			
 
				+# a spool away. A slot is where a spool is loaded, not where it is stored, and
			
 
				+# Bambuddy tracks that separately through slot assignments.
			
 
				+_AMS_SLOT_LOCATION_RE = re.compile(
			
 
				+    r"^(?:.+\s-\s)?(?:AMS[- ]HT [A-Z]\d+|AMS [A-Z]\d+|External Spool)$",
			
 
				+    re.IGNORECASE,
			
 
				+)
			
 
				+
			
 
				+
			
 
				+def is_ams_slot_location(name: str) -> bool:
			
 
				+    """True when a location string names a printer slot rather than a storage place."""
			
 
				+    return bool(_AMS_SLOT_LOCATION_RE.match(name.strip()))
			
 
				+
			
 
				 
			
 
				 def normalize_location_name(name: str) -> str:
			
 
				     trimmed = name.strip()
			
@@ -281,6 +300,9 @@ async def sync_locations_from_spoolman(db: AsyncSession, client) -> bool:
 
				         name = (raw or "").strip()
			
 
				         if not name:
			
 
				             continue
			
 
				+        if is_ams_slot_location(name):
			
 
				+            logger.debug("Skipping AMS slot marker %r from the Spoolman location import", name)
			
 
				+            continue
			
 
				         key = location_name_key(name)
			
 
				         if key not in by_key:
			
 
				             by_key[key] = name
			
--- a/backend/app/services/notification_service.py
+++ b/backend/app/services/notification_service.py
@@ -1869,6 +1869,44 @@ class NotificationService:
 
				             variables=variables,
			
 
				         )
			
 
				 
			
 
				+    async def on_location_ha_sensor_alert(
			
 
				+        self,
			
 
				+        location_name: str,
			
 
				+        sensor_name: str,
			
 
				+        state: str,
			
 
				+        db: AsyncSession,
			
 
				+    ):
			
 
				+        """A Home Assistant sensor bound to a storage location entered its alert state (#2824).
			
 
				+
			
 
				+        Sent immediately rather than folded into a digest, for the same reason
			
 
				+        as on_ha_sensor_alert above: this is the "drybox went stale" case, only
			
 
				+        worth acting on while the humidity/temperature is still climbing.
			
 
				+        """
			
 
				+        # Own column, not on_ha_sensor_alert (#2824): that one can be scoped to
			
 
				+        # a single printer via provider.printer_id, and a location alert has no
			
 
				+        # printer to scope by, so sharing it would leak drybox alerts to a
			
 
				+        # provider narrowed to one printer's sensors.
			
 
				+        providers = await self._get_providers_for_event(db, "on_location_ha_sensor_alert", None)
			
 
				+        if not providers:
			
 
				+            return
			
 
				+
			
 
				+        variables = {
			
 
				+            "location": location_name,
			
 
				+            "sensor": sensor_name,
			
 
				+            "state": state,
			
 
				+        }
			
 
				+
			
 
				+        title, message = await self._build_message_from_template(db, "location_ha_sensor_alert", variables)
			
 
				+        await self._send_to_providers(
			
 
				+            providers,
			
 
				+            title,
			
 
				+            message,
			
 
				+            db,
			
 
				+            "location_ha_sensor_alert",
			
 
				+            force_immediate=True,
			
 
				+            variables=variables,
			
 
				+        )
			
 
				+
			
 
				     async def on_first_layer_complete(
			
 
				         self,
			
 
				         printer_id: int,
			
--- a/backend/app/services/obico_detection.py
+++ b/backend/app/services/obico_detection.py
@@ -96,8 +96,14 @@ class ObicoDetectionService:
 
				         self._states: dict[int, PrintState] = {}
			
 
				         # printer_id -> task_name active when state was created (used to detect new prints)
			
 
				         self._state_keys: dict[int, str] = {}
			
 
				-        # printer_id -> last classification ("safe"/"warning"/"failure")
			
 
				+        # printer_id -> last classification ("safe"/"warning"/"failure").
			
 
				+        # Only written after an inference actually came back, so a missing entry
			
 
				+        # means "we have no verdict", which is not the same as "safe" (#2952).
			
 
				         self._last_class: dict[int, str] = {}
			
 
				+        # printer_id -> why the most recent poll produced no verdict, or absent
			
 
				+        # when the last poll succeeded. Per-printer rather than global so a card
			
 
				+        # can say what went wrong for *that* printer.
			
 
				+        self._errors: dict[int, str] = {}
			
 
				         # printer_id -> whether an action has already been fired for the current print
			
 
				         self._action_fired: dict[int, bool] = {}
			
 
				         # Global detection event log (most-recent-first)
			
@@ -191,6 +197,8 @@ class ObicoDetectionService:
 
				                 self._states.pop(printer_id, None)
			
 
				                 self._state_keys.pop(printer_id, None)
			
 
				                 self._action_fired.pop(printer_id, None)
			
 
				+                self._last_class.pop(printer_id, None)
			
 
				+                self._errors.pop(printer_id, None)
			
 
				                 continue
			
 
				 
			
 
				             await self._check_printer(printer_id, status, settings)
			
@@ -261,6 +269,17 @@ class ObicoDetectionService:
 
				             timeout=SNAPSHOT_CAPTURE_TIMEOUT,
			
 
				         )
			
 
				 
			
 
				+    def _no_verdict(self, printer_id: int, reason: str) -> None:
			
 
				+        """Record that this poll produced no verdict for ``printer_id``.
			
 
				+
			
 
				+        Kept separate from the classification so the status surface can say
			
 
				+        "not checking" instead of inheriting the previous verdict — or, worse,
			
 
				+        the default "safe" a printer used to get before its first inference.
			
 
				+        """
			
 
				+        self._errors[printer_id] = reason
			
 
				+        self._last_error = reason
			
 
				+        logger.warning(reason)
			
 
				+
			
 
				     async def _check_printer(self, printer_id: int, status, settings: dict):
			
 
				         task_name = getattr(status, "task_name", None) or getattr(status, "subtask_name", "") or ""
			
 
				         key = f"{task_name}"
			
@@ -275,17 +294,16 @@ class ObicoDetectionService:
 
				         # keyframe wait.
			
 
				         frame = await self._capture_frame(printer_id)
			
 
				         if not frame:
			
 
				-            self._last_error = f"Failed to capture snapshot for printer {printer_id}"
			
 
				-            logger.warning(self._last_error)
			
 
				+            self._no_verdict(printer_id, f"Failed to capture snapshot for printer {printer_id}")
			
 
				             return
			
 
				 
			
 
				         external_url = settings.get("external_url") or ""
			
 
				         if not external_url:
			
 
				-            self._last_error = (
			
 
				+            self._no_verdict(
			
 
				+                printer_id,
			
 
				                 "external_url setting is empty — Obico's ML API needs a reachable URL to fetch the snapshot from. "
			
 
				-                "Set Settings → General → External URL."
			
 
				+                "Set Settings → General → External URL.",
			
 
				             )
			
 
				-            logger.warning(self._last_error)
			
 
				             return
			
 
				 
			
 
				         nonce = await stash_frame(frame)
			
@@ -304,19 +322,23 @@ class ObicoDetectionService:
 
				                     # Say so plainly: the health endpoint is ungated, so "Test
			
 
				                     # Connection" passes against exactly this configuration and
			
 
				                     # a raw 401 gives the user nothing to act on (#2733).
			
 
				-                    self._last_error = (
			
 
				+                    #
			
 
				+                    # Obico's auth decorator runs before the handler, so a call
			
 
				+                    # rejected here leaves no trace in the ML API's own log —
			
 
				+                    # which is how #2952 came to be reported as "the loop never
			
 
				+                    # calls the ML API" while it was calling it every 10s.
			
 
				+                    self._no_verdict(
			
 
				+                        printer_id,
			
 
				                         "Obico ML API rejected the token (401). Set Settings → Failure Detection → "
			
 
				                         "ML API Token to the ML_API_TOKEN the server runs with, or clear ML_API_TOKEN "
			
 
				-                        "on the server."
			
 
				+                        "on the server.",
			
 
				                     )
			
 
				-                    logger.warning("%s (printer %s)", self._last_error, printer_id)
			
 
				                     return
			
 
				                 resp.raise_for_status()
			
 
				                 payload = resp.json()
			
 
				         except Exception as e:
			
 
				             detail = str(e) or type(e).__name__
			
 
				-            self._last_error = f"ML API call failed for printer {printer_id}: {detail}"
			
 
				-            logger.warning(self._last_error)
			
 
				+            self._no_verdict(printer_id, f"ML API call failed for printer {printer_id}: {detail}")
			
 
				             return
			
 
				 
			
 
				         detections = payload.get("detections", []) if isinstance(payload, dict) else []
			
@@ -328,6 +350,7 @@ class ObicoDetectionService:
 
				         # A successful capture + ML call clears any transient error from previous
			
 
				         # polls (typical case: cold-start RTSP timeout on first frame after startup,
			
 
				         # followed by healthy polls that otherwise leave the banner stuck in the UI).
			
 
				+        self._errors.pop(printer_id, None)
			
 
				         self._last_error = None
			
 
				 
			
 
				         # Log every non-safe sample — safe samples would flood history
			
@@ -371,15 +394,39 @@ class ObicoDetectionService:
 
				 
			
 
				         Only printers with a running, monitored print have a state entry, so
			
 
				         consumers get "show nothing" for idle printers for free.
			
 
				+
			
 
				+        Four classes, and the two non-verdict ones matter as much as the rest:
			
 
				+
			
 
				+        ``error``    the most recent poll produced no verdict. ``error`` carries
			
 
				+                     the reason — a rejected token, an unreachable ML API, a
			
 
				+                     camera that would not yield a frame, an unset External URL.
			
 
				+        ``unknown``  monitored, but no inference has come back yet. The state
			
 
				+                     entry is created when the print is first seen, which is
			
 
				+                     before the first capture, so this is the honest answer for
			
 
				+                     that window.
			
 
				+        ``safe`` / ``warning`` / ``failure``
			
 
				+                     an actual verdict from an actual inference.
			
 
				+
			
 
				+        This used to default to ``safe`` whenever no verdict had been recorded,
			
 
				+        so a printer whose detection had never once succeeded rendered exactly
			
 
				+        like a healthy one: a green badge reading "Safe" at score 0.000. That is
			
 
				+        the worst possible failure mode for a safety feature — it asserts the
			
 
				+        print is being watched precisely when it is not (#2952).
			
 
				         """
			
 
				-        return {
			
 
				-            pid: {
			
 
				-                "class": self._last_class.get(pid, "safe"),
			
 
				+        result = {}
			
 
				+        for pid, state in self._states.items():
			
 
				+            error = self._errors.get(pid)
			
 
				+            if error:
			
 
				+                verdict = "error"
			
 
				+            else:
			
 
				+                verdict = self._last_class.get(pid) or "unknown"
			
 
				+            result[pid] = {
			
 
				+                "class": verdict,
			
 
				                 "frame_count": state.frame_count,
			
 
				                 "score": round(state.ewm_mean, 4),
			
 
				+                "error": error,
			
 
				             }
			
 
				-            for pid, state in self._states.items()
			
 
				-        }
			
 
				+        return result
			
 
				 
			
 
				     def get_status(self, sensitivity: str = "medium") -> dict:
			
 
				         # Report the thresholds for the configured sensitivity, not a hardcoded
			
--- a/backend/app/services/plate_thumbnail.py
+++ b/backend/app/services/plate_thumbnail.py
@@ -132,7 +132,17 @@ def _render_model_thumbnails(threemf_bytes: bytes) -> tuple[bytes | None, bytes
 
				     # Local imports so a `import backend.app.services.plate_thumbnail` from
			
 
				     # an environment without matplotlib/trimesh doesn't fail at import time —
			
 
				     # the function will simply degrade to no-op via the exception branch.
			
 
				-    from backend.app.services.stl_thumbnail import _configure_matplotlib_cache
			
 
				+    #
			
 
				+    # The light angle is IMPORTED rather than mirrored like the palette above.
			
 
				+    # "A plate card and a library thumbnail of the same model look alike" is the
			
 
				+    # whole reason these two renderers share a look, and a second copy of the
			
 
				+    # angle is exactly how that silently stops being true. A palette can afford a
			
 
				+    # copy; a number nobody would notice drifting cannot.
			
 
				+    from backend.app.services.stl_thumbnail import (
			
 
				+        _configure_matplotlib_cache,
			
 
				+        _repair_winding,
			
 
				+        _shade_kwargs,
			
 
				+    )
			
 
				 
			
 
				     _configure_matplotlib_cache()
			
 
				 
			
@@ -141,6 +151,7 @@ def _render_model_thumbnails(threemf_bytes: bytes) -> tuple[bytes | None, bytes
 
				     matplotlib.use("Agg")
			
 
				     import matplotlib.pyplot as plt
			
 
				     import trimesh
			
 
				+    from matplotlib.colors import LightSource
			
 
				     from mpl_toolkits.mplot3d.art3d import Poly3DCollection
			
 
				 
			
 
				     loaded = trimesh.load(io.BytesIO(threemf_bytes), file_type="3mf", force="mesh")
			
@@ -157,6 +168,15 @@ def _render_model_thumbnails(threemf_bytes: bytes) -> tuple[bytes | None, bytes
 
				         except Exception as exc:
			
 
				             logger.debug("plate_thumbnail: mesh simplification failed, using original: %s", exc)
			
 
				 
			
 
				+    # Before the vertices are read, not after: ``scaled`` below is indexed by
			
 
				+    # ``mesh.faces``, so a repair that ever moves a vertex would leave the two
			
 
				+    # out of step. Shared with stl_thumbnail rather than copied — the reason
			
 
				+    # these renderers agree is that they run the same code, not similar code.
			
 
				+    try:
			
 
				+        _repair_winding(mesh, trimesh, "plate_thumbnail")
			
 
				+    except Exception as e:  # best-effort, as the whole module is
			
 
				+        logger.debug("plate_thumbnail: winding repair skipped (%s)", e)
			
 
				+
			
 
				     vertices = mesh.vertices
			
 
				     bounds_min = vertices.min(axis=0)
			
 
				     bounds_max = vertices.max(axis=0)
			
@@ -164,20 +184,36 @@ def _render_model_thumbnails(threemf_bytes: bytes) -> tuple[bytes | None, bytes
 
				     max_extent = (bounds_max - bounds_min).max()
			
 
				     scaled = centered / max_extent if max_extent > 0 else centered
			
 
				 
			
 
				+    # ndarray, not a list of lists — shading walks this to build normals, and the
			
 
				+    # list form is ~30x slower to construct. Paid twice per plate: once per size.
			
 
				     faces = mesh.faces
			
 
				-    poly3d = [[scaled[v] for v in face] for face in faces]
			
 
				+    poly3d = scaled[faces]
			
 
				 
			
 
				-    large = _render_at_size(poly3d, _PLATE_PNG_SIZE, plt, Poly3DCollection)
			
 
				-    small = _render_at_size(poly3d, _PLATE_PNG_SMALL_SIZE, plt, Poly3DCollection)
			
 
				+    # Resolved once and shared: both sizes must be lit identically or the 128px
			
 
				+    # card and the 512px view disagree. Empty for a mesh matplotlib cannot shade,
			
 
				+    # which keeps such a plate rendering flat instead of failing — see
			
 
				+    # ``_shade_kwargs``.
			
 
				+    shade_kw = _shade_kwargs(poly3d, LightSource)
			
 
				+
			
 
				+    large = _render_at_size(poly3d, _PLATE_PNG_SIZE, plt, Poly3DCollection, shade_kw)
			
 
				+    small = _render_at_size(poly3d, _PLATE_PNG_SMALL_SIZE, plt, Poly3DCollection, shade_kw)
			
 
				     return large, small
			
 
				 
			
 
				 
			
 
				-def _render_at_size(poly3d, size: int, plt, Poly3DCollection) -> bytes:
			
 
				+def _render_at_size(poly3d, size: int, plt, Poly3DCollection, shade_kw: dict) -> bytes:
			
 
				     """Render the prepared poly3d collection to an in-memory PNG."""
			
 
				+    # Local, like every other import in this module, so importing plate_thumbnail
			
 
				+    # in an environment without matplotlib still works. stl_thumbnail's own
			
 
				+    # module level is import-light, so this costs nothing after the first call.
			
 
				+    from backend.app.services.stl_thumbnail import VIEW_AZIM_DEG, VIEW_ELEV_DEG
			
 
				+
			
 
				     fig = plt.figure(figsize=(size / 100, size / 100), dpi=100)
			
 
				     fig.patch.set_facecolor(_BACKGROUND_COLOR)
			
 
				     ax = fig.add_subplot(111, projection="3d")
			
 
				     ax.set_facecolor(_BACKGROUND_COLOR)
			
 
				+    # ``shade=True`` needs a real ``edgecolors``: matplotlib shades the edge
			
 
				+    # colours alongside the face colours, and an empty array (``"none"``) makes
			
 
				+    # it raise on the broadcast. Keep the two in step if either moves.
			
 
				     ax.add_collection3d(
			
 
				         Poly3DCollection(
			
 
				             poly3d,
			
@@ -185,12 +221,13 @@ def _render_at_size(poly3d, size: int, plt, Poly3DCollection) -> bytes:
 
				             edgecolors=_BAMBU_GREEN,
			
 
				             linewidths=0.1,
			
 
				             alpha=0.9,
			
 
				+            **shade_kw,
			
 
				         )
			
 
				     )
			
 
				     ax.set_xlim(-0.6, 0.6)
			
 
				     ax.set_ylim(-0.6, 0.6)
			
 
				     ax.set_zlim(-0.6, 0.6)
			
 
				-    ax.view_init(elev=25, azim=45)
			
 
				+    ax.view_init(elev=VIEW_ELEV_DEG, azim=VIEW_AZIM_DEG)
			
 
				     ax.set_axis_off()
			
 
				     ax.grid(False)
			
 
				     plt.subplots_adjust(left=0, right=1, top=1, bottom=0)
			
--- a/backend/app/services/print_batch.py
+++ b/backend/app/services/print_batch.py
@@ -114,6 +114,10 @@ class PlateProgress:
 
				     actual_cost: float | None = None
			
 
				     filament_used_grams: float | None = None
			
 
				     print_time_seconds: int = 0
			
 
				+    # Whether any queue item for this plate still exists, in any status.
			
 
				+    # Dispatch clones one to inherit the print configuration, so a plate with
			
 
				+    # none cannot be queued however many runs it still owes.
			
 
				+    has_source: bool = False
			
 
				 
			
 
				     @property
			
 
				     def dispatched(self) -> int:
			
@@ -123,6 +127,11 @@ class PlateProgress:
 
				     def remaining(self) -> int:
			
 
				         return max(0, self.quantity_target - self.dispatched)
			
 
				 
			
 
				+    @property
			
 
				+    def can_dispatch(self) -> bool:
			
 
				+        """True when this plate owes runs *and* something can produce them."""
			
 
				+        return self.remaining > 0 and self.has_source
			
 
				+
			
 
				     @property
			
 
				     def cost_per_run(self) -> float | None:
			
 
				         """Observed mean cost of this plate's completed runs, or None.
			
@@ -185,6 +194,16 @@ class BatchProgress:
 
				     def remaining(self) -> int:
			
 
				         return self._sum("remaining")
			
 
				 
			
 
				+    @property
			
 
				+    def dispatchable_remaining(self) -> int:
			
 
				+        """Of the runs still owed, how many can actually be queued.
			
 
				+
			
 
				+        Lower than ``remaining`` when a plate's last queue item was deleted:
			
 
				+        the order still owes the run, but nothing survives to clone its
			
 
				+        printer target, AMS mapping and print options from.
			
 
				+        """
			
 
				+        return sum(p.remaining for p in self.plates if p.has_source)
			
 
				+
			
 
				     @property
			
 
				     def actual_cost(self) -> float | None:
			
 
				         costs = [p.actual_cost for p in self.plates if p.actual_cost is not None]
			
@@ -282,6 +301,11 @@ async def load_progress(db: AsyncSession, batch: PrintBatch) -> BatchProgress:
 
				                 plate.quantity_target += count
			
 
				         elif not progress.has_targets and status in CONSUMING_STATUSES:
			
 
				             plate.quantity_target += count
			
 
				+        # Any surviving row is a clone source, whatever its status — a
			
 
				+        # cancelled or failed run still carries the configuration a re-queue
			
 
				+        # needs. Set before the status filter below so a status this module
			
 
				+        # has no counter for still marks the plate dispatchable.
			
 
				+        plate.has_source = True
			
 
				         if status in COUNTED_STATUSES:
			
 
				             setattr(plate, status, getattr(plate, status) + count)
			
 
				         else:
			
@@ -462,6 +486,18 @@ def _clone_queue_item(source: PrintQueueItem, *, position: int, created_by_id: i
 
				     return clone
			
 
				 
			
 
				 
			
 
				+def _plate_label(plate: PlateProgress) -> str:
			
 
				+    """How a plate is named in an error the user reads.
			
 
				+
			
 
				+    Prefers the plate name the order stored, because that is what the Batches
			
 
				+    tab shows; falls back to the plate number for orders created before names
			
 
				+    were recorded.
			
 
				+    """
			
 
				+    if plate.plate_name:
			
 
				+        return plate.plate_name
			
 
				+    return f"Plate {plate.plate_id if plate.plate_id is not None else 1}"
			
 
				+
			
 
				+
			
 
				 async def dispatch_remaining(
			
 
				     db: AsyncSession,
			
 
				     batch: PrintBatch,
			
@@ -478,9 +514,12 @@ async def dispatch_remaining(
 
				     otherwise every plate with work outstanding is dispatched in plate order.
			
 
				     ``limit`` caps the total number of items created across all plates.
			
 
				 
			
 
				-    Raises :class:`BatchDispatchError` when a plate owes runs but has no
			
 
				-    existing item to clone — the order can describe work it has never once
			
 
				-    dispatched, and there is no configuration to copy in that case.
			
 
				+    Raises :class:`BatchDispatchError` when nothing at all can be produced
			
 
				+    because no plate that owes runs has an item to clone — the order can
			
 
				+    describe work whose every run has since been deleted, and there is no
			
 
				+    configuration to copy in that case. A plate in that state is skipped
			
 
				+    rather than aborting the whole order: one unrecoverable plate must not
			
 
				+    block the plates that are still perfectly dispatchable.
			
 
				     """
			
 
				     progress = await load_progress(db, batch)
			
 
				     if not progress.has_targets:
			
@@ -491,6 +530,7 @@ async def dispatch_remaining(
 
				         targets = [p for p in targets if p.plate_id == plate_id]
			
 
				 
			
 
				     created: list[PrintQueueItem] = []
			
 
				+    stranded: list[PlateProgress] = []
			
 
				 
			
 
				     for plate in targets:
			
 
				         if limit is not None and len(created) >= limit:
			
@@ -508,10 +548,8 @@ async def dispatch_remaining(
 
				         ).scalar_one_or_none()
			
 
				 
			
 
				         if source is None:
			
 
				-            raise BatchDispatchError(
			
 
				-                f"Plate {plate.plate_id if plate.plate_id is not None else 1} has no queued or finished run to "
			
 
				-                "copy settings from. Queue it once from the file, then dispatch the rest from here."
			
 
				-            )
			
 
				+            stranded.append(plate)
			
 
				+            continue
			
 
				 
			
 
				         wanted = plate.remaining
			
 
				         if limit is not None:
			
@@ -533,11 +571,20 @@ async def dispatch_remaining(
 
				                 db.add(cloned_variant)
			
 
				             created.append(clone)
			
 
				 
			
 
				+    if not created and stranded:
			
 
				+        names = ", ".join(_plate_label(p) for p in stranded)
			
 
				+        raise BatchDispatchError(
			
 
				+            f"{names} {'have' if len(stranded) > 1 else 'has'} no queued or finished run to copy settings from. "
			
 
				+            "Queue the plate once from the file, then dispatch the rest from here."
			
 
				+        )
			
 
				+
			
 
				     if created:
			
 
				         # Dispatching more work can only ever un-fulfil an order, but run the
			
 
				         # check anyway so a reopened batch flips back from completed.
			
 
				         await db.flush()
			
 
				         await refresh_batch_status(db, batch)
			
 
				 
			
 
				+    if stranded:
			
 
				+        logger.info("Batch %s: skipped %d plate(s) with no item to clone", batch.id, len(stranded))
			
 
				     logger.info("Dispatched %d item(s) for batch %s", len(created), batch.id)
			
 
				     return created
			
--- a/backend/app/services/print_cost_estimate.py
+++ b/backend/app/services/print_cost_estimate.py
@@ -12,6 +12,7 @@ from backend.app.core.config import settings
 
				 from backend.app.models.archive import PrintArchive
			
 
				 from backend.app.models.library import LibraryFile
			
 
				 from backend.app.models.spool_assignment import SpoolAssignment
			
 
				+from backend.app.services.inventory_mode import spoolman_owns_assignments
			
 
				 from backend.app.utils import threemf_tools
			
 
				 from backend.app.utils.safe_path import safe_join_under
			
 
				 
			
@@ -135,7 +136,11 @@ async def estimate_queue_source_cost(
 
				     default_cost = await _default_cost_per_kg(db)
			
 
				     cost_by_tray: dict[int, float | None] = {}
			
 
				     mapping = _parse_mapping(ams_mapping)
			
 
				-    if printer_id is not None and mapping:
			
 
				+    # Built-in spool prices only. In Spoolman mode the built-in table may still
			
 
				+    # hold rows from before the user switched -- nothing clears it since #2812 --
			
 
				+    # and pricing an estimate from a spool the printer is not drawing on would
			
 
				+    # be worse than the default rate this falls back to.
			
 
				+    if printer_id is not None and mapping and not await spoolman_owns_assignments(db):
			
 
				         assignments = (
			
 
				             (
			
 
				                 await db.execute(
			
--- a/backend/app/services/print_scheduler.py
+++ b/backend/app/services/print_scheduler.py
--- a/backend/app/services/print_storage.py
+++ b/backend/app/services/print_storage.py
@@ -7,10 +7,9 @@ FTPS on port 990. On every Bambu model that port serves **external storage only*
 
				 H2-series and P2S firmware default to keeping the sliced file on internal eMMC
			
 
				 instead, and BambuStudio uploads there over a separate service on port 6000
			
 
				 (the "BambuTunnelLocal" protocol -- see #2762, which tracks implementing it).
			
 
				-When that happens there is no file on FTPS to find, at any path, and no TLS
			
 
				-option, retry or directory guess changes that. The dispatch says so plainly:
			
 
				-the ``project_file`` command carries ``url``, which is ``ftp://<name>`` for
			
 
				-external storage and ``brtc://emmc/<name>`` for internal.
			
 
				+The dispatch says where it went: the ``project_file`` command carries ``url``,
			
 
				+which is ``ftp://<name>`` for external storage and ``brtc://emmc/<name>`` for
			
 
				+internal.
			
 
				 
			
 
				 Before this module we ignored ``url`` and swept anyway: six filename variants
			
 
				 across five directories with up to four retries for the 3MF, then sixteen more
			
@@ -19,6 +18,19 @@ print, every one of them certain to 550. The user-visible result was an archive
 
				 card with nothing on it and no stated reason, which read as a Bambuddy bug and
			
 
				 was reported as one four times (#1170, #2524, #2762, #2780).
			
 
				 
			
 
				+But that URL is not the last word on reachability, and reading it as one was
			
 
				+itself a regression (#2856). It says where the printer *chose* to put the file,
			
 
				+not whether port 990 can serve it -- measured on an H2D (firmware 01.03.00.00,
			
 
				+card in the slot): every ``brtc://emmc/<name>`` print of that reporter's was
			
 
				+sitting under ``/cache/<name>`` and downloaded fine, 19 MB included, until this
			
 
				+module started skipping the lookup. On #2780's P2S and H2C the same URL really
			
 
				+did mean nothing was there. So an internal-storage URL earns a *bounded probe*
			
 
				+rather than a skip: it names the exact file, which turns the 110-connection
			
 
				+sweep into one connection walking five paths, and the answer comes from the
			
 
				+printer instead of from a guess about its model. Only when that probe misses
			
 
				+does the verdict's ``reason`` stand -- see :func:`probe_filename_from_url` and
			
 
				+:func:`ftp_probe_paths`, and the callers that run it.
			
 
				+
			
 
				 The rule here is deliberately one-sided: **skip only on positive evidence**.
			
 
				 Silence is not evidence -- a printer that never publishes ``sdcard`` and never
			
 
				 had a ``project_file`` pass through the request topic (some brokers refuse the
			
@@ -30,28 +42,75 @@ from __future__ import annotations
 
				 
			
 
				 from dataclasses import dataclass
			
 
				 
			
 
				-# The one URL scheme that means "on external storage, reachable over FTPS".
			
 
				-# Anything else -- brtc://emmc today, whatever Bambu ships next -- is somewhere
			
 
				-# port 990 does not serve. Matching the reachable value rather than the
			
 
				-# unreachable one is what keeps a new scheme from silently reading as fine.
			
 
				+# The scheme that means "uploaded to external storage, reachable over FTPS".
			
 
				+# An unknown scheme -- whatever Bambu ships next -- must not read as fine, so
			
 
				+# this matches the reachable value rather than the unreachable one.
			
 
				 _EXTERNAL_STORAGE_SCHEME = "ftp"
			
 
				 
			
 
				+# ``file://`` means the file was already on the printer when the print started:
			
 
				+# a reprint from the touchscreen, from Handy, or a Studio send-to-storage
			
 
				+# followed by a print. The path says which storage, and only the printer's own
			
 
				+# internal roots are out of reach of port 990. Measured on an H2D, 2026-08-17:
			
 
				+# ``file:///media/usb0/foobar.gcode.3mf`` while that exact file was listable and
			
 
				+# downloadable over FTPS.
			
 
				+_LOCAL_FILE_SCHEME = "file"
			
 
				+
			
 
				+# Internal roots seen in ``file://`` paths. ``/userdata`` is where the model
			
 
				+# cache lives (``/userdata/model/history/<name>``, confirmed via the printer's
			
 
				+# own file listing), and port 990 does not serve it.
			
 
				+_INTERNAL_FILE_PREFIXES = ("/userdata/",)
			
 
				+
			
 
				 # Reason slugs. These cross the API into the UI and into the connection
			
 
				 # diagnostic, so they are part of the contract: the frontend maps each to its
			
 
				 # own explanation and its own advice. Keep them stable.
			
 
				 REASON_INTERNAL_STORAGE = "internal_storage"
			
 
				 REASON_NO_EXTERNAL_STORAGE = "no_external_storage"
			
 
				 
			
 
				+# Same verdict as REASON_INTERNAL_STORAGE, different cause -- and the cause is
			
 
				+# the whole of the advice. `brtc://emmc/<name>` is a *dispatch* that chose
			
 
				+# internal storage: a slicer sent the file and the printer filed it where port
			
 
				+# 990 cannot serve it, which the operator can change by sending it elsewhere.
			
 
				+# `file:///userdata/...` is a print of a file that was already on the printer --
			
 
				+# a touchscreen re-print, a Handy start, a Studio send-to-storage printed later
			
 
				+# -- so there was no dispatch to aim anywhere, and telling that operator to pick
			
 
				+# "External" in Send describes a step they never took (#1820).
			
 
				+REASON_INTERNAL_HISTORY = "internal_history"
			
 
				+
			
 
				+# Not a storage verdict — the file's location was never in question. The
			
 
				+# printer's FTPS service was inside its post-failed-handshake cool-off when the
			
 
				+# print started, so the sweep was skipped without a single connection. Stamped
			
 
				+# on the fallback archive by the print-start handler rather than returned by
			
 
				+# `_verdict`, and unlike the two above it is temporary: it is the one reason a
			
 
				+# retry is worth scheduling (#2957).
			
 
				+REASON_FTPS_COOLOFF = "ftps_cooloff"
			
 
				+
			
 
				+# Where a sliced file has ever been found over FTPS, in the order the sweep in
			
 
				+# `main.py` tries them -- root first, which is where A1/P1-series uploads land
			
 
				+# (#972), then `/cache`, which is where the H2D keeps its copy of an eMMC job
			
 
				+# (#2856).
			
 
				+_PROBE_DIRECTORIES = ("/", "/cache/", "/model/", "/data/", "/data/Metadata/")
			
 
				+
			
 
				+# Longest name worth probing for. Every filesystem the printer could be serving
			
 
				+# from caps a name at 255 bytes, so anything past this cannot be a file that is
			
 
				+# actually there -- and it would be written to a local temp path too.
			
 
				+_MAX_PROBE_FILENAME_LENGTH = 255
			
 
				+
			
 
				 
			
 
				 @dataclass(frozen=True)
			
 
				 class StorageVerdict:
			
 
				     """Whether an FTPS sweep for this print's file is worth running.
			
 
				 
			
 
				     ``reachable`` False always carries a ``reason``; True never does.
			
 
				+
			
 
				+    ``probe_filename`` is the exact name the dispatch gave, present only on an
			
 
				+    unreachable verdict and only when the URL named a ``.3mf``. It is the
			
 
				+    caller's chance to check the claim cheaply before acting on ``reason`` --
			
 
				+    see :func:`ftp_probe_paths`.
			
 
				     """
			
 
				 
			
 
				     reachable: bool
			
 
				     reason: str | None = None
			
 
				+    probe_filename: str | None = None
			
 
				 
			
 
				 
			
 
				 _REACHABLE = StorageVerdict(reachable=True)
			
@@ -68,13 +127,74 @@ def url_is_external_storage(project_url: str | None) -> bool | None:
 
				     # string is not an answer.
			
 
				     if not isinstance(project_url, str) or not project_url:
			
 
				         return None
			
 
				-    scheme, separator, _ = project_url.partition("://")
			
 
				+    scheme, separator, path = project_url.partition("://")
			
 
				     if not separator:
			
 
				         # No scheme at all. Real dispatches always carry one, so rather than
			
 
				         # guess at a bare path, decline to answer and let the caller fall
			
 
				         # through to its existing behaviour.
			
 
				         return None
			
 
				-    return scheme.lower() == _EXTERNAL_STORAGE_SCHEME
			
 
				+    scheme = scheme.lower()
			
 
				+    if scheme == _EXTERNAL_STORAGE_SCHEME:
			
 
				+        return True
			
 
				+    if scheme == _LOCAL_FILE_SCHEME:
			
 
				+        # Only a known-internal path is positive evidence of somewhere FTPS
			
 
				+        # cannot reach. Anything else is unknown, which sweeps -- this module
			
 
				+        # skips only on positive evidence, and a path we do not recognise is
			
 
				+        # not that. Returning False here instead is what made a print of a file
			
 
				+        # sitting on the stick report as internal storage and archive with no
			
 
				+        # 3MF, when the sweep would have found it immediately.
			
 
				+        if path.startswith(_INTERNAL_FILE_PREFIXES):
			
 
				+            return False
			
 
				+        return None
			
 
				+    return False
			
 
				+
			
 
				+
			
 
				+def probe_filename_from_url(project_url: str | None) -> str | None:
			
 
				+    """The exact 3MF name *project_url* points at, for a bounded FTPS probe.
			
 
				+
			
 
				+    ``brtc://emmc/Cube.gcode.3mf`` -> ``Cube.gcode.3mf``, and likewise for the
			
 
				+    internal ``file://`` paths. ``None`` when there is no name to probe with,
			
 
				+    which is the caller's signal to fall back to the sweep it would have run.
			
 
				+
			
 
				+    Only ``.3mf`` names come back. A print running from a bare gcode has no 3MF
			
 
				+    to find at any path, so probing for one would spend connections to learn
			
 
				+    what the extension already said.
			
 
				+
			
 
				+    The value arrives from the network -- whatever the slicer or the printer
			
 
				+    put in the dispatch -- and callers turn it into both a remote path and a
			
 
				+    local temp filename, so anything that could steer either is refused rather
			
 
				+    than sanitized: no separators, no traversal, no control characters.
			
 
				+    """
			
 
				+    if not isinstance(project_url, str):
			
 
				+        return None
			
 
				+    _scheme, separator, path = project_url.partition("://")
			
 
				+    if not separator:
			
 
				+        return None
			
 
				+    name = path.rpartition("/")[2].strip()
			
 
				+    if not name or len(name) > _MAX_PROBE_FILENAME_LENGTH:
			
 
				+        return None
			
 
				+    # A leading dot is either a traversal segment or a hidden file; neither is
			
 
				+    # a sliced upload, and both would put an odd path on the wire. A backslash
			
 
				+    # is a path separator on the host even though it is a legal character in
			
 
				+    # the printer's own filesystem, which is how a name could reach outside the
			
 
				+    # temp directory it is written to.
			
 
				+    if name.startswith(".") or "\\" in name:
			
 
				+        return None
			
 
				+    if any(character < " " or character == "\x7f" for character in name):
			
 
				+        return None
			
 
				+    if not name.lower().endswith(".3mf"):
			
 
				+        return None
			
 
				+    return name
			
 
				+
			
 
				+
			
 
				+def ftp_probe_paths(filename: str) -> list[str]:
			
 
				+    """Remote paths to try for *filename*, best first.
			
 
				+
			
 
				+    One filename across the known directories, because the dispatch already
			
 
				+    told us the name and only the directory is in question (#2856). Callers
			
 
				+    walk the list over a single connection, against the sweep's ~110.
			
 
				+    """
			
 
				+    return [f"{directory}{filename}" for directory in _PROBE_DIRECTORIES]
			
 
				 
			
 
				 
			
 
				 def external_storage_present(state: object | None) -> bool:
			
@@ -120,6 +240,18 @@ def last_print_storage_verdict(state: object | None) -> StorageVerdict:
 
				     return _verdict(getattr(state, "last_project_url", None), state)
			
 
				 
			
 
				 
			
 
				+def _internal_reason(project_url: str | None) -> str:
			
 
				+    """Which flavour of "internal" *project_url* names.
			
 
				+
			
 
				+    Only ever reached on a negative verdict, so the URL is one of the two
			
 
				+    shapes :func:`url_is_external_storage` answers False for.
			
 
				+    """
			
 
				+    if not isinstance(project_url, str):
			
 
				+        return REASON_INTERNAL_STORAGE
			
 
				+    scheme = project_url.partition("://")[0].lower()
			
 
				+    return REASON_INTERNAL_HISTORY if scheme == _LOCAL_FILE_SCHEME else REASON_INTERNAL_STORAGE
			
 
				+
			
 
				+
			
 
				 def _verdict(project_url: str | None, state: object | None) -> StorageVerdict:
			
 
				     if state is None:
			
 
				         return _REACHABLE
			
@@ -128,7 +260,16 @@ def _verdict(project_url: str | None, state: object | None) -> StorageVerdict:
 
				     # named the destination.
			
 
				     external = url_is_external_storage(project_url)
			
 
				     if external is False:
			
 
				-        return StorageVerdict(reachable=False, reason=REASON_INTERNAL_STORAGE)
			
 
				+        # Worth probing only if there is external storage for the probe to find
			
 
				+        # anything on. An empty slot answers the question the probe would ask,
			
 
				+        # and #2780's H2C sat that way for three weeks -- one connection per
			
 
				+        # print start is small, but it is not worth spending to be told what
			
 
				+        # the printer already said.
			
 
				+        return StorageVerdict(
			
 
				+            reachable=False,
			
 
				+            reason=_internal_reason(project_url),
			
 
				+            probe_filename=probe_filename_from_url(project_url) if external_storage_present(state) else None,
			
 
				+        )
			
 
				     if external is True:
			
 
				         # It said external storage, so sweep even if the card flags disagree.
			
 
				         # Trusting the specific claim over the general one is what keeps a
			
--- a/backend/app/services/printer_diagnostic.py
+++ b/backend/app/services/printer_diagnostic.py
@@ -17,11 +17,17 @@ import ssl
 
				 
			
 
				 from backend.app.models.printer import Printer
			
 
				 from backend.app.schemas.printer import DiagnosticCheck, PrinterDiagnosticResult
			
 
				+from backend.app.services.bambu_ftp import find_remote_file_async
			
 
				 from backend.app.services.bambu_mqtt import CONNECT_ERROR_AUTH_REJECTED
			
 
				 from backend.app.services.camera import get_camera_port
			
 
				 from backend.app.services.discovery import is_running_in_docker
			
 
				 from backend.app.services.ftp_profiles import get_ftp_profile
			
 
				-from backend.app.services.print_storage import REASON_INTERNAL_STORAGE, last_print_storage_verdict
			
 
				+from backend.app.services.print_storage import (
			
 
				+    REASON_INTERNAL_STORAGE,
			
 
				+    StorageVerdict,
			
 
				+    ftp_probe_paths,
			
 
				+    last_print_storage_verdict,
			
 
				+)
			
 
				 from backend.app.services.printer_manager import printer_manager
			
 
				 from backend.app.utils.printer_models import has_external_storage, has_remote_storage_toggle
			
 
				 
			
@@ -35,6 +41,12 @@ PORT_CHAMBER_IMAGE = 6000  # Chamber image protocol — A1/P1 camera stream; opt
 
				 
			
 
				 _PORT_PROBE_TIMEOUT = 3.0
			
 
				 
			
 
				+# Cap for the storage probe (#2856). One connection and a handful of directory
			
 
				+# listings, so a healthy printer answers in well under a second. Kept short on
			
 
				+# purpose: this check sits inside the support bundle's 15s-per-printer budget,
			
 
				+# and in the interactive run it is spinner time the user is watching.
			
 
				+_STORAGE_PROBE_TIMEOUT = 6.0
			
 
				+
			
 
				 # Default seconds the `printer_publishing` check will wait for the first
			
 
				 # report-topic message before declaring fail. Bambu printers in idle publish
			
 
				 # push_status every few seconds; 10s catches healthy bridges with margin while
			
@@ -116,6 +128,53 @@ async def _check_ftps_tls(ip: str, model: str | None, timeout: float = _PORT_PRO
 
				                 pass
			
 
				 
			
 
				 
			
 
				+async def _last_print_file_is_reachable(
			
 
				+    printer: Printer | None,
			
 
				+    verdict: StorageVerdict,
			
 
				+    *,
			
 
				+    ftps_ok: bool,
			
 
				+) -> bool:
			
 
				+    """Did the last print's file turn up on external storage after all? (#2856)
			
 
				+
			
 
				+    ``verdict`` is read off the dispatch URL, which says where the printer
			
 
				+    *put* the file, not whether port 990 can serve it: an H2D with a card in
			
 
				+    the slot reports ``brtc://emmc/<name>`` and then hands the same file over
			
 
				+    from ``/cache`` without complaint. Warning that the file is out of reach
			
 
				+    while that user's archives are quietly complete would send them chasing a
			
 
				+    setting that is already right.
			
 
				+
			
 
				+    So check before saying it -- one connection, one listing per candidate
			
 
				+    directory, no transfer, and only for the check that is about to warn.
			
 
				+    "Could not check" returns False and leaves the warning standing, which is
			
 
				+    the safe direction: it is a warn, not a fail.
			
 
				+    """
			
 
				+    if not ftps_ok or not verdict.probe_filename or printer is None:
			
 
				+        return False
			
 
				+    # Attribute reads inside the guard too: this also runs from the support
			
 
				+    # bundle, where the row may outlive its session, and a detached-instance
			
 
				+    # error there is "could not check", not a broken diagnostic.
			
 
				+    ip_address = None
			
 
				+    try:
			
 
				+        ip_address = getattr(printer, "ip_address", None)
			
 
				+        access_code = getattr(printer, "access_code", None)
			
 
				+        if not ip_address or not access_code:
			
 
				+            return False
			
 
				+        found = await find_remote_file_async(
			
 
				+            ip_address,
			
 
				+            access_code,
			
 
				+            ftp_probe_paths(verdict.probe_filename),
			
 
				+            timeout=_STORAGE_PROBE_TIMEOUT,
			
 
				+            socket_timeout=_STORAGE_PROBE_TIMEOUT,
			
 
				+            printer_model=getattr(printer, "model", None),
			
 
				+        )
			
 
				+    except Exception as e:
			
 
				+        logger.debug("Could not probe %s for %s: %s", ip_address, verdict.probe_filename, e)
			
 
				+        return False
			
 
				+    if found:
			
 
				+        logger.debug("Last print file is on external storage at %s despite %s", found, verdict.reason)
			
 
				+    return found is not None
			
 
				+
			
 
				+
			
 
				 def _auth_reason_params(reason: str | None) -> dict:
			
 
				     """Map a client's CONNACK-refusal slug onto the check's `params.reason`.
			
 
				 
			
@@ -329,18 +388,32 @@ async def run_connection_diagnostic(
 
				                 params={"reason": "no_media"},
			
 
				             )
			
 
				         )
			
 
				-    elif not last_print_storage_verdict(state).reachable:
			
 
				-        # The toggle is on, a card is in, and the printer still put the last
			
 
				-        # print on internal storage — which is what H2-series and P2S firmware
			
 
				-        # does, and no setting here changes it (#2762 tracks reading that
			
 
				-        # storage). A pass here would be a lie; a fail would be unresolvable.
			
 
				+    elif not (last_verdict := last_print_storage_verdict(state)).reachable and not await _last_print_file_is_reachable(
			
 
				+        printer, last_verdict, ftps_ok=ftps_state == "ok"
			
 
				+    ):
			
 
				+        # The toggle is on, a card is in, the printer said the last print's file
			
 
				+        # is on internal storage — and a probe confirmed it really is out of
			
 
				+        # reach. That is what H2-series and P2S firmware does, and no setting
			
 
				+        # here changes it (#2762 tracks reading that storage). A pass here would
			
 
				+        # be a lie; a fail would be unresolvable.
			
 
				+        #
			
 
				+        # The verdict's own reason, not a fixed one: a print started from the
			
 
				+        # printer's screen reaches this branch too, and it never involved a
			
 
				+        # slicer, so the advice attached to REASON_INTERNAL_STORAGE would name a
			
 
				+        # dialog its operator never opened (#1820).
			
 
				         checks.append(
			
 
				             DiagnosticCheck(
			
 
				                 id="external_storage",
			
 
				                 status="warn",
			
 
				-                params={"reason": REASON_INTERNAL_STORAGE},
			
 
				+                params={"reason": last_verdict.reason or REASON_INTERNAL_STORAGE},
			
 
				             )
			
 
				         )
			
 
				+    elif not last_verdict.reachable:
			
 
				+        # Reached only when the probe above found the file: the printer named
			
 
				+        # internal storage and served it over FTPS anyway. What this check is
			
 
				+        # for is whether Bambuddy can read the print file, and it demonstrably
			
 
				+        # can — so pass, whatever the toggle happens to say (#2856).
			
 
				+        checks.append(DiagnosticCheck(id="external_storage", status="pass"))
			
 
				     elif store_to_sdcard is True:
			
 
				         checks.append(DiagnosticCheck(id="external_storage", status="pass"))
			
 
				     elif store_to_sdcard is False:
			
--- a/backend/app/services/printer_manager.py
+++ b/backend/app/services/printer_manager.py
@@ -8,7 +8,14 @@ from sqlalchemy import select
 
				 from sqlalchemy.ext.asyncio import AsyncSession
			
 
				 
			
 
				 from backend.app.models.printer import Printer
			
 
				-from backend.app.services.bambu_mqtt import BambuMQTTClient, MQTTLogEntry, PrinterState, get_stage_name
			
 
				+from backend.app.services.bambu_mqtt import (
			
 
				+    STAGE_NAMES,
			
 
				+    BambuMQTTClient,
			
 
				+    MQTTLogEntry,
			
 
				+    PrinterState,
			
 
				+    get_stage_name,
			
 
				+)
			
 
				+from backend.app.utils.kprofile_lookup import build_slot_k_resolver
			
 
				 
			
 
				 logger = logging.getLogger(__name__)
			
 
				 
			
@@ -398,12 +405,20 @@ class PrinterManager:
 
				         self._clients: dict[int, BambuMQTTClient] = {}
			
 
				         self._models: dict[int, str | None] = {}  # Cache printer models for feature detection
			
 
				         self._printer_info: dict[int, PrinterInfo] = {}  # Cache printer name/serial for callbacks
			
 
				+        # Last AMS / external-spool reading of a printer whose client has been
			
 
				+        # dropped, so the queue can still tell which machine holds which colour
			
 
				+        # (#2876). Deliberately outside the client's own state: it answers
			
 
				+        # "what did this printer last have loaded", not "what is it reporting
			
 
				+        # now", and the two must not be confused by anything that displays or
			
 
				+        # merges live status.
			
 
				+        self._last_trays: dict[int, dict] = {}
			
 
				         self._on_print_start: Callable[[int, dict], None] | None = None
			
 
				         self._on_print_complete: Callable[[int, dict], None] | None = None
			
 
				         self._on_print_running_observed: Callable[[int, dict], None] | None = None
			
 
				         self._on_finish_photo_moment: Callable[[int, dict], None] | None = None
			
 
				         self._on_status_change: Callable[[int, PrinterState], None] | None = None
			
 
				         self._on_ams_change: Callable[[int, list], None] | None = None
			
 
				+        self._on_fts_inlet_change: Callable[[int, int, str], None] | None = None
			
 
				         self._on_layer_change: Callable[[int, int], None] | None = None
			
 
				         self._on_print_progress: Callable[[int, int], None] | None = None
			
 
				         self._on_bed_temp_update: Callable[[int, float], None] | None = None
			
@@ -492,7 +507,14 @@ class PrinterManager:
 
				         """
			
 
				         printer = self.get_printer(printer_id)
			
 
				         if not printer:
			
 
				-            return
			
 
				+            # No cached info means no client is registered — the printer was
			
 
				+            # disconnected outright rather than merely powered off. The gate is
			
 
				+            # still releasable from the API in that state (#2864), and a retained
			
 
				+            # MQTT topic left saying "awaiting" would outlive the truth, so fall
			
 
				+            # back to the row rather than dropping the emission.
			
 
				+            printer = await self._printer_info_from_db(printer_id)
			
 
				+            if not printer:
			
 
				+                return
			
 
				 
			
 
				         try:
			
 
				             from backend.app.services.mqtt_relay import mqtt_relay
			
@@ -515,6 +537,20 @@ class PrinterManager:
 
				         except Exception as e:
			
 
				             logger.warning("Failed to send plate-clear notification for printer %d: %s", printer_id, e)
			
 
				 
			
 
				+    async def _printer_info_from_db(self, printer_id: int) -> PrinterInfo | None:
			
 
				+        """Name and serial for a printer with no registered client."""
			
 
				+        from backend.app.core.database import async_session
			
 
				+
			
 
				+        try:
			
 
				+            async with async_session() as db:
			
 
				+                row = (
			
 
				+                    await db.execute(select(Printer.name, Printer.serial_number).where(Printer.id == printer_id))
			
 
				+                ).first()
			
 
				+        except Exception as e:
			
 
				+            logger.warning("Failed to load printer %d info from DB: %s", printer_id, e)
			
 
				+            return None
			
 
				+        return PrinterInfo(row[0], row[1]) if row else None
			
 
				+
			
 
				     async def _broadcast_status_change(self, printer_id: int) -> None:
			
 
				         """Emit a ``printer_status`` WebSocket update for this printer (#1128).
			
 
				 
			
@@ -626,6 +662,14 @@ class PrinterManager:
 
				         """Set callback for AMS data change events."""
			
 
				         self._on_ams_change = callback
			
 
				 
			
 
				+    def set_fts_inlet_change_callback(self, callback: Callable[[int, int, str], None]):
			
 
				+        """Set callback for Filament Track Switch inlet moves.
			
 
				+
			
 
				+        Receives ``(printer_id, ams_id, inlet)``. Fired only when an AMS moves
			
 
				+        between inlets, not on the first sighting of a binding.
			
 
				+        """
			
 
				+        self._on_fts_inlet_change = callback
			
 
				+
			
 
				     def set_layer_change_callback(self, callback: Callable[[int, int], None]):
			
 
				         """Set callback for layer change events. Receives (printer_id, layer_num)."""
			
 
				         self._on_layer_change = callback
			
@@ -689,6 +733,29 @@ class PrinterManager:
 
				 
			
 
				             future.add_done_callback(handle_exception)
			
 
				 
			
 
				+    def last_known_trays(self, printer_id: int) -> dict:
			
 
				+        """What this printer last had loaded, for a printer with no live client.
			
 
				+
			
 
				+        Only the tray keys, and only as history: a caller that wants to know
			
 
				+        what a printer is reporting *now* must use :meth:`get_status`. This
			
 
				+        exists because dropping a client drops its status with it, and the
			
 
				+        queue reads the loaded filament to decide which offline printer is
			
 
				+        worth switching on (#2876) — ``_power_on_and_wait`` replaces the client
			
 
				+        on every attempt, so without this each attempt erased the reading the
			
 
				+        next one needs.
			
 
				+        """
			
 
				+        return self._last_trays.get(printer_id, {})
			
 
				+
			
 
				+    def _remember_trays(self, printer_id: int) -> None:
			
 
				+        """Keep the tray reading of a client that is about to be dropped."""
			
 
				+        client = self._clients.get(printer_id)
			
 
				+        if not client:
			
 
				+            return
			
 
				+        raw = client.state.raw_data or {}
			
 
				+        remembered = {key: raw[key] for key in ("ams", "vt_tray") if raw.get(key)}
			
 
				+        if remembered:
			
 
				+            self._last_trays[printer_id] = remembered
			
 
				+
			
 
				     async def connect_printer(self, printer: Printer) -> bool:
			
 
				         """Connect to a printer."""
			
 
				         if printer.id in self._clients:
			
@@ -720,6 +787,10 @@ class PrinterManager:
 
				             if self._on_ams_change:
			
 
				                 self._schedule_async(self._on_ams_change(printer_id, ams_data))
			
 
				 
			
 
				+        def on_fts_inlet_change(ams_id: int, inlet: str):
			
 
				+            if self._on_fts_inlet_change:
			
 
				+                self._schedule_async(self._on_fts_inlet_change(printer_id, ams_id, inlet))
			
 
				+
			
 
				         def on_layer_change(layer_num: int):
			
 
				             if self._on_layer_change:
			
 
				                 self._schedule_async(self._on_layer_change(printer_id, layer_num))
			
@@ -753,6 +824,7 @@ class PrinterManager:
 
				             on_print_start=on_print_start,
			
 
				             on_print_complete=on_print_complete,
			
 
				             on_ams_change=on_ams_change,
			
 
				+            on_fts_inlet_change=on_fts_inlet_change,
			
 
				             on_layer_change=on_layer_change,
			
 
				             on_print_progress=on_print_progress,
			
 
				             on_bed_temp_update=on_bed_temp_update,
			
@@ -775,6 +847,7 @@ class PrinterManager:
 
				     def disconnect_printer(self, printer_id: int, timeout: float = 0):
			
 
				         """Disconnect from a printer."""
			
 
				         if printer_id in self._clients:
			
 
				+            self._remember_trays(printer_id)
			
 
				             self._clients[printer_id].disconnect(timeout=timeout)
			
 
				             del self._clients[printer_id]
			
 
				         self._models.pop(printer_id, None)  # Clean up model cache
			
@@ -1103,6 +1176,23 @@ def get_derived_status_name(state: PrinterState, model: str | None = None) -> st
 
				     # X1 models use -1 for idle, A1/P1 models use 255 for idle
			
 
				     # Valid stage numbers are 0-254
			
 
				     if 0 <= state.stg_cur < 255:
			
 
				+        # A stage number the table does not cover is named "Preparing" rather
			
 
				+        # than "Unknown stage (72)". New models report stages before Bambuddy
			
 
				+        # learns their names -- the H2C still has several -- and the card is
			
 
				+        # the wrong place to say so: the number means nothing to the person
			
 
				+        # reading it, and every stage that has ever turned out to be unnamed
			
 
				+        # was part of the run-up to printing, so "Preparing" is both the more
			
 
				+        # useful answer and the more likely one.
			
 
				+        #
			
 
				+        # This is display only, and deliberately not pushed down into
			
 
				+        # `get_stage_name`. That function also feeds the stage-transition log
			
 
				+        # line and the once-per-session warning that exists precisely to
			
 
				+        # capture unnamed stages so they can be named later (bambu_mqtt.py
			
 
				+        # ~4100) -- there the number is the entire diagnostic value, and
			
 
				+        # replacing it with "Preparing" would hide the very thing that
			
 
				+        # reports these.
			
 
				+        if state.stg_cur not in STAGE_NAMES:
			
 
				+            return "Preparing"
			
 
				         return get_stage_name(state.stg_cur)
			
 
				 
			
 
				     # If not in RUNNING state, no derived status needed
			
@@ -1264,14 +1354,11 @@ def printer_state_to_dict(
 
				     vt_tray = []
			
 
				     raw_data = state.raw_data or {}
			
 
				 
			
 
				-    # Build K-profile lookup map: cali_idx -> k_value
			
 
				-    kprofile_map: dict[int, float] = {}
			
 
				-    for kp in state.kprofiles or []:
			
 
				-        if kp.slot_id is not None and kp.k_value:
			
 
				-            try:
			
 
				-                kprofile_map[kp.slot_id] = float(kp.k_value)
			
 
				-            except (ValueError, TypeError):
			
 
				-                pass  # Skip K-profile entries with unparseable values
			
 
				+    # K value for a slot's bound profile. Shared with the REST serializer of
			
 
				+    # the same card (routes/printers.py) so the two cannot answer differently:
			
 
				+    # this one used to key on cali_idx alone, which on a dual-nozzle machine
			
 
				+    # meant whichever nozzle's table was listed last won the slot.
			
 
				+    resolve_slot_k = build_slot_k_resolver(state)
			
 
				 
			
 
				     if "ams" in raw_data and isinstance(raw_data["ams"], list):
			
 
				         for ams_data in raw_data["ams"]:
			
@@ -1287,8 +1374,8 @@ def printer_state_to_dict(
 
				                 # Get K value: first try tray's k field, then lookup from K-profiles
			
 
				                 k_value = tray.get("k")
			
 
				                 cali_idx = tray.get("cali_idx")
			
 
				-                if k_value is None and cali_idx is not None and cali_idx in kprofile_map:
			
 
				-                    k_value = kprofile_map[cali_idx]
			
 
				+                if k_value is None:
			
 
				+                    k_value = resolve_slot_k(cali_idx, int(ams_data.get("id", 0)), int(tray.get("id", 0)))
			
 
				 
			
 
				                 # P1S / A1 Mini physically-empty-slot signal (#1322 follow-up by
			
 
				                 # @RosdasHH): for a truly empty slot the firmware sends only
			
@@ -1420,8 +1507,11 @@ def printer_state_to_dict(
 
				             # Get K value for vt_tray
			
 
				             vt_k_value = vt_data.get("k")
			
 
				             vt_cali_idx = vt_data.get("cali_idx")
			
 
				-            if vt_k_value is None and vt_cali_idx is not None and vt_cali_idx in kprofile_map:
			
 
				-                vt_k_value = kprofile_map[vt_cali_idx]
			
 
				+            if vt_k_value is None:
			
 
				+                # External holder: id 254 is Ext-L, 255 is Ext-R. The resolver
			
 
				+                # takes the 0/1 tray index, so normalise before asking.
			
 
				+                vt_id = int(vt_data.get("id", 254))
			
 
				+                vt_k_value = resolve_slot_k(vt_cali_idx, 255, vt_id - 254 if vt_id >= 254 else vt_id)
			
 
				 
			
 
				             tray_id = int(vt_data.get("id", 254))
			
 
				             vt_tray.append(
			
@@ -1473,6 +1563,10 @@ def printer_state_to_dict(
 
				                 "actions": e.actions,
			
 
				                 "job_id": e.job_id,
			
 
				                 "full_code": e.full_code,
			
 
				+                # Same field as the status response carries (#2926) — a relay
			
 
				+                # watching the stream should not have to poll REST to find out
			
 
				+                # what a fault means.
			
 
				+                "description": e.description,
			
 
				             }
			
 
				             for e in (state.hms_errors or [])
			
 
				         ],
			
@@ -1507,6 +1601,53 @@ def printer_state_to_dict(
 
				         ),
			
 
				         # Per-AMS extruder map: {ams_id: extruder_id} where 0=right, 1=left
			
 
				         "ams_extruder_map": ams_extruder_map,
			
 
				+        # Filament Track Switch. Both fields have to travel on the WebSocket, not
			
 
				+        # only on the REST status: the frontend shallow-merges each push over its
			
 
				+        # cached status, so a field that is absent here keeps whatever the last
			
 
				+        # full fetch left behind. Omitting them meant the AMS inlet badges only
			
 
				+        # ever changed on a page reload.
			
 
				+        "fila_switch": (
			
 
				+            {
			
 
				+                "installed": True,
			
 
				+                "in_slots": list(state.fila_switch.in_slots),
			
 
				+                "out_extruders": list(state.fila_switch.out_extruders),
			
 
				+                "stat": state.fila_switch.stat,
			
 
				+                "info": state.fila_switch.info,
			
 
				+                # Mirrors BambuStudio's DevFilaSwitch::IsReady — every AMS has to
			
 
				+                # be bound to an inlet before the switch can route anything. Until
			
 
				+                # the operator has done that on the printer's Manual AMS Setup
			
 
				+                # screen, Studio refuses a load outright rather than sending a
			
 
				+                # command the firmware cannot act on, and so do we.
			
 
				+                # An empty AMS list is "ready", as it is in Studio: there is then
			
 
				+                # no slot to load from, so nothing can reach the check anyway, and
			
 
				+                # reporting not-ready would only mean a confusing toast on a
			
 
				+                # payload that has not carried the AMS block yet.
			
 
				+                #
			
 
				+                # An AMS still reporting a real extruder id rather than 0xE has no
			
 
				+                # inlet entry, so a machine with one hard-wired unit reads as not
			
 
				+                # ready. That looks harsh but is exactly Studio's own rule —
			
 
				+                # IsReady() requires a switcher position on *every* AMS, and only
			
 
				+                # the 0xE branch ever sets one (DevFilaSystem.cpp:596-615).
			
 
				+                "ready": all(str(u["id"]) in state.ams_switch_inlet for u in ams_units),
			
 
				+            }
			
 
				+            if state.fila_switch and state.fila_switch.installed
			
 
				+            else None
			
 
				+        ),
			
 
				+        # Per-AMS FTS inlet binding: {ams_id: "A" | "B"}. Gated on the accessory
			
 
				+        # so a stale binding cannot outlive it being unplugged.
			
 
				+        "ams_switch_inlet": (dict(state.ams_switch_inlet) if state.fila_switch and state.fila_switch.installed else {}),
			
 
				+        # Which AMS slot each hotend is fed from: {extruder_id: {...}}. Travels on
			
 
				+        # the WebSocket for the same reason as fila_switch above — the frontend
			
 
				+        # shallow-merges pushes over its cached status, so an absent field keeps a
			
 
				+        # stale value forever. Empty on printers that do not report it.
			
 
				+        "extruder_slots": {
			
 
				+            str(ext_id): {
			
 
				+                "ams_id": slot.ams_id,
			
 
				+                "slot_id": slot.slot_id,
			
 
				+                "has_filament": slot.has_filament,
			
 
				+            }
			
 
				+            for ext_id, slot in state.extruder_slots.items()
			
 
				+        },
			
 
				         # WiFi signal strength
			
 
				         "wifi_signal": state.wifi_signal,
			
 
				         "wired_network": state.wired_network,
			
--- a/backend/app/services/printer_media.py
+++ b/backend/app/services/printer_media.py
@@ -0,0 +1,728 @@
 
				+"""Helpers for matching and downloading printer-side video files."""
			
 
				+
			
 
				+from __future__ import annotations
			
 
				+
			
 
				+import asyncio
			
 
				+import json
			
 
				+import logging
			
 
				+import re
			
 
				+import secrets
			
 
				+import shutil
			
 
				+import tempfile
			
 
				+import time
			
 
				+import zipfile
			
 
				+from collections.abc import Awaitable, Callable
			
 
				+from dataclasses import dataclass, replace
			
 
				+from datetime import datetime, timedelta, timezone
			
 
				+from pathlib import Path, PurePosixPath
			
 
				+
			
 
				+from backend.app.core.config import settings
			
 
				+from backend.app.core.tasks import spawn_background_task
			
 
				+from backend.app.services.bambu_ftp import (
			
 
				+    DownloadCancelled,
			
 
				+    DownloadInsufficientSpace,
			
 
				+    DownloadLimitExceeded,
			
 
				+    download_file_async,
			
 
				+)
			
 
				+
			
 
				+logger = logging.getLogger(__name__)
			
 
				+
			
 
				+VIDEO_SUFFIXES = (".mp4", ".avi", ".mkv")
			
 
				+MAX_PRINTER_ZIP_BYTES = 10 * 1024**3
			
 
				+PRINTER_ZIP_FREE_SPACE_RESERVE = 256 * 1024**2
			
 
				+_STALE_BUNDLE_SECONDS = 60 * 60
			
 
				+MAX_PRINTER_ZIP_PREPARE_SECONDS = 30 * 60
			
 
				+MAX_OPEN_ARCHIVE_IPCAM_SECONDS = 24 * 60 * 60
			
 
				+_BUNDLE_KEY_RE = re.compile(r"^[A-Za-z0-9_-]{1,200}$")
			
 
				+_JOB_KEY_RE = re.compile(r"^[A-Za-z0-9_-]{20,200}$")
			
 
				+_LOCAL_JOB_TASKS: dict[str, asyncio.Task] = {}
			
 
				+_cleanup_task: asyncio.Task | None = None
			
 
				+_CLEANUP_INTERVAL_SECONDS = 15 * 60
			
 
				+
			
 
				+
			
 
				+class PrinterFilesZipTooLargeError(ValueError):
			
 
				+    """The selected printer files exceed the bounded ZIP staging limit."""
			
 
				+
			
 
				+
			
 
				+class PrinterFilesZipInsufficientSpaceError(OSError):
			
 
				+    """The app data volume cannot safely stage the selected files."""
			
 
				+
			
 
				+
			
 
				+@dataclass(frozen=True)
			
 
				+class PrinterFilesZipResult:
			
 
				+    """Result of staging one printer ZIP."""
			
 
				+
			
 
				+    path: Path
			
 
				+    requested: int
			
 
				+    successful: int
			
 
				+    failed_paths: tuple[str, ...]
			
 
				+    total_bytes: int
			
 
				+
			
 
				+
			
 
				+@dataclass(frozen=True)
			
 
				+class PrinterFilesJobStatus:
			
 
				+    """Serializable state for an asynchronous browser preparation job."""
			
 
				+
			
 
				+    job_id: str
			
 
				+    printer_id: int
			
 
				+    state: str
			
 
				+    requested: int
			
 
				+    successful: int = 0
			
 
				+    failed: int = 0
			
 
				+    token: str | None = None
			
 
				+    filename: str | None = None
			
 
				+    message: str | None = None
			
 
				+
			
 
				+
			
 
				+class _FileCancelSignal:
			
 
				+    """Cross-worker cancellation signal checked by the FTP callback thread."""
			
 
				+
			
 
				+    def __init__(self, path: Path):
			
 
				+        self.path = path
			
 
				+        self._last_check = 0.0
			
 
				+        self._cached = False
			
 
				+
			
 
				+    def is_set(self) -> bool:
			
 
				+        if self._cached:
			
 
				+            return True
			
 
				+        now = time.monotonic()
			
 
				+        if now - self._last_check >= 0.25:
			
 
				+            self._last_check = now
			
 
				+            self._cached = self.path.exists()
			
 
				+        return self._cached
			
 
				+
			
 
				+
			
 
				+def _job_status_path(job_id: str) -> Path:
			
 
				+    if not _JOB_KEY_RE.fullmatch(job_id):
			
 
				+        raise ValueError("Invalid printer download job id")
			
 
				+    return _printer_zip_root() / f"job-{job_id}.json"
			
 
				+
			
 
				+
			
 
				+def _job_cancel_path(job_id: str) -> Path:
			
 
				+    if not _JOB_KEY_RE.fullmatch(job_id):
			
 
				+        raise ValueError("Invalid printer download job id")
			
 
				+    return _printer_zip_root() / f"job-{job_id}.cancel"
			
 
				+
			
 
				+
			
 
				+def _write_job_status(status: PrinterFilesJobStatus) -> None:
			
 
				+    """Atomically publish job state for polling from any app worker."""
			
 
				+
			
 
				+    path = _job_status_path(status.job_id)
			
 
				+    temp_path = path.with_suffix(".tmp")
			
 
				+    temp_path.write_text(json.dumps(status.__dict__, separators=(",", ":")), encoding="utf-8")
			
 
				+    temp_path.replace(path)
			
 
				+
			
 
				+
			
 
				+def _read_job_status(job_id: str) -> PrinterFilesJobStatus | None:
			
 
				+    try:
			
 
				+        data = json.loads(_job_status_path(job_id).read_text(encoding="utf-8"))
			
 
				+        return PrinterFilesJobStatus(**data)
			
 
				+    except (FileNotFoundError, OSError, ValueError, TypeError, json.JSONDecodeError):
			
 
				+        return None
			
 
				+
			
 
				+
			
 
				+def _naive_utc(value: datetime | None) -> datetime | None:
			
 
				+    if value is None:
			
 
				+        return None
			
 
				+    if value.tzinfo is not None:
			
 
				+        return value.astimezone(timezone.utc).replace(tzinfo=None)
			
 
				+    return value
			
 
				+
			
 
				+
			
 
				+def match_ipcam_chunks(
			
 
				+    files: list[dict],
			
 
				+    started_at: datetime | None,
			
 
				+    completed_at: datetime | None,
			
 
				+    *,
			
 
				+    now: datetime | None = None,
			
 
				+) -> list[dict]:
			
 
				+    """Return `/ipcam` chunks whose completion time overlaps a print.
			
 
				+
			
 
				+    Bambu's `ipcam-record.*.mp4` files are fixed-size chunks. On the tested X1C
			
 
				+    and H2D firmware, their FTP mtime is the chunk completion time in the same
			
 
				+    UTC-naive basis used by archive timestamps. Some firmware reports FTP LIST
			
 
				+    mtimes in printer-local time instead; LIST carries no timezone with which
			
 
				+    to correct those values reliably. A ten-minute tail includes the final
			
 
				+    chunk, whose mtime lands after the print-complete event.
			
 
				+    """
			
 
				+
			
 
				+    start = _naive_utc(started_at)
			
 
				+    if start is None:
			
 
				+        return []
			
 
				+    live_end = _naive_utc(now) or datetime.now(timezone.utc).replace(tzinfo=None)
			
 
				+    # A crash can leave an archive in ``printing`` indefinitely. Do not turn
			
 
				+    # that stale row into a window covering every chunk created since then.
			
 
				+    end = _naive_utc(completed_at) or min(live_end, start + timedelta(seconds=MAX_OPEN_ARCHIVE_IPCAM_SECONDS))
			
 
				+    lower = start - timedelta(minutes=1)
			
 
				+    upper = max(start, end) + timedelta(minutes=10)
			
 
				+
			
 
				+    matches: list[dict] = []
			
 
				+    for file in files:
			
 
				+        name = str(file.get("name") or "")
			
 
				+        mtime = file.get("mtime")
			
 
				+        if file.get("is_directory") or not name.lower().startswith("ipcam-record."):
			
 
				+            continue
			
 
				+        if not name.lower().endswith(VIDEO_SUFFIXES) or not isinstance(mtime, datetime):
			
 
				+            continue
			
 
				+        timestamp = _naive_utc(mtime)
			
 
				+        if timestamp is not None and lower <= timestamp <= upper:
			
 
				+            matches.append(file)
			
 
				+
			
 
				+    matches.sort(key=lambda item: _naive_utc(item.get("mtime")) or datetime.min)
			
 
				+    return matches
			
 
				+
			
 
				+
			
 
				+def _zip_arcname(remote_path: str, used: set[str]) -> str:
			
 
				+    """Return a safe, unique relative archive name for a printer path."""
			
 
				+
			
 
				+    parts = [part for part in PurePosixPath(remote_path).parts if part not in ("/", "", ".", "..")]
			
 
				+    candidate = "/".join(parts) or "printer-file"
			
 
				+    stem = candidate
			
 
				+    suffix = ""
			
 
				+    if "." in PurePosixPath(candidate).name:
			
 
				+        suffix = "".join(PurePosixPath(candidate).suffixes)
			
 
				+        stem = candidate[: -len(suffix)] if suffix else candidate
			
 
				+    counter = 2
			
 
				+    while candidate in used:
			
 
				+        candidate = f"{stem}-{counter}{suffix}"
			
 
				+        counter += 1
			
 
				+    used.add(candidate)
			
 
				+    return candidate
			
 
				+
			
 
				+
			
 
				+def _printer_zip_root() -> Path:
			
 
				+    """Return the dedicated staging root without doing event-loop I/O."""
			
 
				+
			
 
				+    return settings.archive_dir / "temp" / "printer-file-downloads"
			
 
				+
			
 
				+
			
 
				+def _ensure_printer_zip_root() -> Path:
			
 
				+    """Create and return the staging root on the persistent data volume."""
			
 
				+
			
 
				+    root = _printer_zip_root()
			
 
				+    root.mkdir(parents=True, exist_ok=True)
			
 
				+    return root
			
 
				+
			
 
				+
			
 
				+def _prune_stale_bundles(root: Path) -> None:
			
 
				+    """Remove abandoned bundles after token expiry, without touching archives."""
			
 
				+
			
 
				+    cutoff = time.time() - _STALE_BUNDLE_SECONDS
			
 
				+    if not root.exists():
			
 
				+        return
			
 
				+    for child in root.iterdir():
			
 
				+        try:
			
 
				+            if child.is_dir() and child.stat().st_mtime < cutoff:
			
 
				+                shutil.rmtree(child, ignore_errors=True)
			
 
				+            elif child.is_file() and child.name.startswith("job-") and child.stat().st_mtime < cutoff:
			
 
				+                child.unlink(missing_ok=True)
			
 
				+        except OSError:
			
 
				+            continue
			
 
				+
			
 
				+
			
 
				+async def prune_stale_printer_file_bundles() -> None:
			
 
				+    """Prune abandoned printer ZIPs without blocking the event loop."""
			
 
				+
			
 
				+    root = await asyncio.to_thread(_ensure_printer_zip_root)
			
 
				+    await asyncio.to_thread(_prune_stale_bundles, root)
			
 
				+
			
 
				+
			
 
				+async def _printer_download_cleanup_loop() -> None:
			
 
				+    while True:
			
 
				+        try:
			
 
				+            await asyncio.sleep(_CLEANUP_INTERVAL_SECONDS)
			
 
				+            await prune_stale_printer_file_bundles()
			
 
				+        except asyncio.CancelledError:
			
 
				+            break
			
 
				+        except Exception:
			
 
				+            logger.exception("Periodic printer-download cleanup failed")
			
 
				+
			
 
				+
			
 
				+def start_printer_download_cleanup() -> None:
			
 
				+    global _cleanup_task
			
 
				+    if _cleanup_task is None:
			
 
				+        _cleanup_task = spawn_background_task(_printer_download_cleanup_loop(), name="printer-download-cleanup")
			
 
				+
			
 
				+
			
 
				+async def stop_printer_download_cleanup() -> None:
			
 
				+    """Stop cleanup and cancel every in-process preparation before shutdown."""
			
 
				+
			
 
				+    global _cleanup_task
			
 
				+    tasks: list[asyncio.Task] = []
			
 
				+    cleanup_task = _cleanup_task
			
 
				+    _cleanup_task = None
			
 
				+    if cleanup_task is not None:
			
 
				+        cleanup_task.cancel()
			
 
				+        tasks.append(cleanup_task)
			
 
				+
			
 
				+    # Jobs can be inside an FTP worker thread. Publish the same cooperative
			
 
				+    # cancellation marker used by the DELETE endpoint before cancelling the
			
 
				+    # asyncio wrapper, then await every wrapper so no executor work is left
			
 
				+    # behind when the application event loop closes.
			
 
				+    for job_id, task in list(_LOCAL_JOB_TASKS.items()):
			
 
				+        if not task.done():
			
 
				+            await asyncio.to_thread(_job_cancel_path(job_id).touch)
			
 
				+            task.cancel()
			
 
				+        tasks.append(task)
			
 
				+    if tasks:
			
 
				+        await asyncio.gather(*tasks, return_exceptions=True)
			
 
				+    _LOCAL_JOB_TASKS.clear()
			
 
				+
			
 
				+
			
 
				+def printer_files_zip_path(printer_id: int, token: str) -> Path | None:
			
 
				+    """Resolve the staged ZIP for a resource-bound browser token."""
			
 
				+
			
 
				+    bundle_key = f"{printer_id}-{token}"
			
 
				+    if not _BUNDLE_KEY_RE.fullmatch(bundle_key):
			
 
				+        return None
			
 
				+    return _printer_zip_root() / bundle_key / "printer-files.zip"
			
 
				+
			
 
				+
			
 
				+def bind_printer_files_zip_to_token(
			
 
				+    result: PrinterFilesZipResult,
			
 
				+    printer_id: int,
			
 
				+    token: str,
			
 
				+) -> PrinterFilesZipResult:
			
 
				+    """Move a prepared bundle to the path derived from its persisted token."""
			
 
				+
			
 
				+    target = printer_files_zip_path(printer_id, token)
			
 
				+    if target is None:
			
 
				+        raise ValueError("Invalid printer ZIP token")
			
 
				+    result.path.parent.rename(target.parent)
			
 
				+    return replace(result, path=target)
			
 
				+
			
 
				+
			
 
				+def _check_initial_space(root: Path, sizes: dict[str, int]) -> None:
			
 
				+    # These sizes are client-reported hints used only for an early rejection,
			
 
				+    # so this is a courtesy, not the bound. The real one is enforced per write
			
 
				+    # and per FTP callback below, against actual bytes and the live free space,
			
 
				+    # which is the only thing that can hold when several preparations run at
			
 
				+    # once -- and they do: nothing serializes them. Two concurrent jobs that
			
 
				+    # both pass here stop independently at the reserve, and the one that gets
			
 
				+    # there second fails with a message saying so.
			
 
				+    expected_total = sum(sizes.values())
			
 
				+    if expected_total > MAX_PRINTER_ZIP_BYTES:
			
 
				+        raise PrinterFilesZipTooLargeError(
			
 
				+            f"Selected files total {expected_total} bytes; the limit is {MAX_PRINTER_ZIP_BYTES} bytes"
			
 
				+        )
			
 
				+
			
 
				+    largest_file = max(sizes.values(), default=0)
			
 
				+    # In the worst case the ZIP is as large as the inputs while the largest
			
 
				+    # source is still staged beside it. Keep a reserve for the database/logs.
			
 
				+    required = expected_total + largest_file + PRINTER_ZIP_FREE_SPACE_RESERVE
			
 
				+    free = shutil.disk_usage(root).free
			
 
				+    if free < required:
			
 
				+        raise PrinterFilesZipInsufficientSpaceError(
			
 
				+            f"The app data volume needs {required} bytes free to stage this selection; {free} bytes are available"
			
 
				+        )
			
 
				+
			
 
				+
			
 
				+async def build_printer_files_zip(
			
 
				+    printer,
			
 
				+    paths: list[str],
			
 
				+    sizes: dict[str, int],
			
 
				+    *,
			
 
				+    bundle_key: str | None = None,
			
 
				+    preserve_paths: bool = True,
			
 
				+    allow_empty: bool = False,
			
 
				+    cancel_signal: _FileCancelSignal | None = None,
			
 
				+    progress_callback: Callable[[int, int], Awaitable[None]] | None = None,
			
 
				+) -> PrinterFilesZipResult:
			
 
				+    """Download printer files one at a time into a disk-backed ZIP.
			
 
				+
			
 
				+    The previous implementation held every source file and the final ZIP in
			
 
				+    memory. Continuous `/ipcam` chunks are commonly ~250 MB each, so selecting
			
 
				+    only a few could exhaust both server and browser memory.
			
 
				+    """
			
 
				+
			
 
				+    root = await asyncio.to_thread(_ensure_printer_zip_root)
			
 
				+    await asyncio.to_thread(_prune_stale_bundles, root)
			
 
				+    await asyncio.to_thread(_check_initial_space, root, sizes)
			
 
				+    bundle_dir: Path | None = None
			
 
				+    try:
			
 
				+        if bundle_key is None:
			
 
				+            bundle_dir = Path(await asyncio.to_thread(tempfile.mkdtemp, prefix="bundle-", dir=root))
			
 
				+        else:
			
 
				+            if not _BUNDLE_KEY_RE.fullmatch(bundle_key):
			
 
				+                raise ValueError("Invalid printer ZIP bundle key")
			
 
				+            bundle_dir = root / bundle_key
			
 
				+            await asyncio.to_thread(bundle_dir.mkdir, mode=0o700)
			
 
				+        zip_path = bundle_dir / "printer-files.zip"
			
 
				+        successful = 0
			
 
				+        total_bytes = 0
			
 
				+        failed_paths: list[str] = []
			
 
				+        used_names: set[str] = set()
			
 
				+
			
 
				+        archive = await asyncio.to_thread(zipfile.ZipFile, zip_path, "w", allowZip64=True)
			
 
				+        try:
			
 
				+            for index, remote_path in enumerate(paths):
			
 
				+                if cancel_signal is not None and cancel_signal.is_set():
			
 
				+                    raise asyncio.CancelledError
			
 
				+                if not isinstance(remote_path, str) or not remote_path.startswith("/") or "\x00" in remote_path:
			
 
				+                    logger.warning("Skipping invalid printer file path: %r", remote_path)
			
 
				+                    failed_paths.append(remote_path)
			
 
				+                    continue
			
 
				+                staged_path = bundle_dir / f"download-{index}"
			
 
				+                try:
			
 
				+                    expected_size = sizes.get(remote_path)
			
 
				+                    if expected_size is not None:
			
 
				+                        free = (await asyncio.to_thread(shutil.disk_usage, root)).free
			
 
				+                        if free < expected_size + PRINTER_ZIP_FREE_SPACE_RESERVE:
			
 
				+                            raise PrinterFilesZipInsufficientSpaceError(
			
 
				+                                "The app data volume lacks space for the next selected file"
			
 
				+                            )
			
 
				+                    downloaded = await download_file_async(
			
 
				+                        printer.ip_address,
			
 
				+                        printer.access_code,
			
 
				+                        remote_path,
			
 
				+                        staged_path,
			
 
				+                        timeout=600,
			
 
				+                        socket_timeout=60,
			
 
				+                        printer_model=printer.model,
			
 
				+                        expected_size=expected_size,
			
 
				+                        max_bytes=MAX_PRINTER_ZIP_BYTES - total_bytes,
			
 
				+                        cancel_event=cancel_signal,
			
 
				+                        min_free_bytes=PRINTER_ZIP_FREE_SPACE_RESERVE,
			
 
				+                        # Outside the per-printer download gate (#2957), in both
			
 
				+                        # directions. A selection of ~250 MB /ipcam chunks holds
			
 
				+                        # the printer for as long as it legitimately takes, and
			
 
				+                        # nothing else should be made to wait that out; equally,
			
 
				+                        # each file here must not stall behind a thumbnail.
			
 
				+                        serialize=False,
			
 
				+                    )
			
 
				+                    if not downloaded:
			
 
				+                        failed_paths.append(remote_path)
			
 
				+                        continue
			
 
				+                    # Deliberately no second size comparison here. The transfer
			
 
				+                    # was already checked against the printer's own SIZE, which
			
 
				+                    # download_to_file treats as the authority precisely because
			
 
				+                    # it beats a hint the browser round-tripped; re-judging the
			
 
				+                    # result against that hint would overrule the better number
			
 
				+                    # with the worse one. The hint goes stale in exactly the case
			
 
				+                    # this feature exists for -- an /ipcam chunk or a timelapse
			
 
				+                    # still being written when the listing was taken -- and a
			
 
				+                    # complete file would then be dropped as "truncated".
			
 
				+                    file_size = (await asyncio.to_thread(staged_path.stat)).st_size
			
 
				+                    if total_bytes + file_size > MAX_PRINTER_ZIP_BYTES:
			
 
				+                        raise PrinterFilesZipTooLargeError(
			
 
				+                            f"Downloaded files exceed the {MAX_PRINTER_ZIP_BYTES}-byte limit"
			
 
				+                        )
			
 
				+                    free = (await asyncio.to_thread(shutil.disk_usage, root)).free
			
 
				+                    if free < file_size + PRINTER_ZIP_FREE_SPACE_RESERVE:
			
 
				+                        raise PrinterFilesZipInsufficientSpaceError(
			
 
				+                            "The app data volume ran out of safe staging space while building the ZIP"
			
 
				+                        )
			
 
				+                    compression = (
			
 
				+                        zipfile.ZIP_STORED if remote_path.lower().endswith(VIDEO_SUFFIXES) else zipfile.ZIP_DEFLATED
			
 
				+                    )
			
 
				+                    arc_source = remote_path if preserve_paths else PurePosixPath(remote_path).name
			
 
				+                    await asyncio.to_thread(
			
 
				+                        archive.write,
			
 
				+                        staged_path,
			
 
				+                        _zip_arcname(arc_source, used_names),
			
 
				+                        compress_type=compression,
			
 
				+                    )
			
 
				+                    successful += 1
			
 
				+                    total_bytes += file_size
			
 
				+                except DownloadLimitExceeded as exc:
			
 
				+                    raise PrinterFilesZipTooLargeError(
			
 
				+                        f"Downloaded files exceed the {MAX_PRINTER_ZIP_BYTES}-byte limit"
			
 
				+                    ) from exc
			
 
				+                except DownloadInsufficientSpace as exc:
			
 
				+                    raise PrinterFilesZipInsufficientSpaceError(
			
 
				+                        "The app data volume ran out of safe staging space during transfer"
			
 
				+                    ) from exc
			
 
				+                except DownloadCancelled as exc:
			
 
				+                    raise asyncio.CancelledError from exc
			
 
				+                except (PrinterFilesZipTooLargeError, PrinterFilesZipInsufficientSpaceError):
			
 
				+                    raise
			
 
				+                except Exception as exc:
			
 
				+                    logger.warning("Failed to add %s to printer ZIP: %s", remote_path, exc)
			
 
				+                    failed_paths.append(remote_path)
			
 
				+                finally:
			
 
				+                    await asyncio.to_thread(staged_path.unlink, missing_ok=True)
			
 
				+                    if progress_callback is not None:
			
 
				+                        await progress_callback(successful, len(failed_paths))
			
 
				+        finally:
			
 
				+            await asyncio.shield(asyncio.to_thread(archive.close))
			
 
				+    except BaseException:
			
 
				+        if bundle_dir is not None:
			
 
				+            await asyncio.shield(asyncio.to_thread(shutil.rmtree, bundle_dir, ignore_errors=True))
			
 
				+        raise
			
 
				+
			
 
				+    if successful == 0 and not allow_empty:
			
 
				+        await asyncio.to_thread(shutil.rmtree, bundle_dir, ignore_errors=True)
			
 
				+        raise FileNotFoundError("No files could be downloaded")
			
 
				+    return PrinterFilesZipResult(
			
 
				+        path=zip_path,
			
 
				+        requested=len(paths),
			
 
				+        successful=successful,
			
 
				+        failed_paths=tuple(failed_paths),
			
 
				+        total_bytes=total_bytes,
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+def printer_file_path(printer_id: int, token: str) -> Path | None:
			
 
				+    """Resolve a prepared native single-file download."""
			
 
				+
			
 
				+    bundle_key = f"{printer_id}-{token}"
			
 
				+    if not _BUNDLE_KEY_RE.fullmatch(bundle_key):
			
 
				+        return None
			
 
				+    return _printer_zip_root() / bundle_key / "printer-file"
			
 
				+
			
 
				+
			
 
				+def bind_printer_file_to_token(result: PrinterFilesZipResult, printer_id: int, token: str) -> PrinterFilesZipResult:
			
 
				+    target = printer_file_path(printer_id, token)
			
 
				+    if target is None:
			
 
				+        raise ValueError("Invalid printer file token")
			
 
				+    result.path.parent.rename(target.parent)
			
 
				+    return replace(result, path=target)
			
 
				+
			
 
				+
			
 
				+async def build_printer_file(
			
 
				+    printer,
			
 
				+    remote_path: str,
			
 
				+    expected_size: int | None,
			
 
				+    *,
			
 
				+    bundle_key: str,
			
 
				+    cancel_signal: _FileCancelSignal | None = None,
			
 
				+) -> PrinterFilesZipResult:
			
 
				+    """Stage one printer file on disk for a browser-native download.
			
 
				+
			
 
				+    Also the read path for the 3MF preview in the file browser, which is why
			
 
				+    nothing here waits on a shared lock: a preview must not queue behind
			
 
				+    somebody else's ten-gigabyte selection for as long as that takes.
			
 
				+    """
			
 
				+
			
 
				+    if not remote_path.startswith("/") or "\x00" in remote_path:
			
 
				+        raise FileNotFoundError("Invalid printer file path")
			
 
				+    root = await asyncio.to_thread(_ensure_printer_zip_root)
			
 
				+    size_hints = {remote_path: expected_size} if expected_size is not None else {}
			
 
				+    await asyncio.to_thread(_check_initial_space, root, size_hints)
			
 
				+    bundle_dir = root / bundle_key
			
 
				+    try:
			
 
				+        await asyncio.to_thread(bundle_dir.mkdir, mode=0o700)
			
 
				+        local_path = bundle_dir / "printer-file"
			
 
				+        downloaded = await download_file_async(
			
 
				+            printer.ip_address,
			
 
				+            printer.access_code,
			
 
				+            remote_path,
			
 
				+            local_path,
			
 
				+            timeout=600,
			
 
				+            socket_timeout=60,
			
 
				+            printer_model=printer.model,
			
 
				+            expected_size=expected_size,
			
 
				+            max_bytes=MAX_PRINTER_ZIP_BYTES,
			
 
				+            cancel_event=cancel_signal,
			
 
				+            min_free_bytes=PRINTER_ZIP_FREE_SPACE_RESERVE,
			
 
				+            # The lock-free promise in this function's docstring, kept: a preview
			
 
				+            # must not queue behind somebody else's selection (#2957).
			
 
				+            serialize=False,
			
 
				+        )
			
 
				+        if not downloaded:
			
 
				+            raise FileNotFoundError("The selected printer file could not be downloaded")
			
 
				+        file_size = (await asyncio.to_thread(local_path.stat)).st_size
			
 
				+        return PrinterFilesZipResult(
			
 
				+            path=local_path,
			
 
				+            requested=1,
			
 
				+            successful=1,
			
 
				+            failed_paths=(),
			
 
				+            total_bytes=file_size,
			
 
				+        )
			
 
				+    except DownloadLimitExceeded as exc:
			
 
				+        await asyncio.shield(asyncio.to_thread(shutil.rmtree, bundle_dir, ignore_errors=True))
			
 
				+        raise PrinterFilesZipTooLargeError(f"Downloaded file exceeds the {MAX_PRINTER_ZIP_BYTES}-byte limit") from exc
			
 
				+    except DownloadInsufficientSpace as exc:
			
 
				+        await asyncio.shield(asyncio.to_thread(shutil.rmtree, bundle_dir, ignore_errors=True))
			
 
				+        raise PrinterFilesZipInsufficientSpaceError(
			
 
				+            "The app data volume ran out of safe staging space during transfer"
			
 
				+        ) from exc
			
 
				+    except DownloadCancelled as exc:
			
 
				+        await asyncio.shield(asyncio.to_thread(shutil.rmtree, bundle_dir, ignore_errors=True))
			
 
				+        raise asyncio.CancelledError from exc
			
 
				+    except BaseException:
			
 
				+        await asyncio.shield(asyncio.to_thread(shutil.rmtree, bundle_dir, ignore_errors=True))
			
 
				+        raise
			
 
				+
			
 
				+
			
 
				+async def _run_printer_files_job(
			
 
				+    printer,
			
 
				+    job_id: str,
			
 
				+    paths: list[str],
			
 
				+    sizes: dict[str, int],
			
 
				+    filename: str,
			
 
				+    as_zip: bool,
			
 
				+) -> None:
			
 
				+    from backend.app.core.auth import create_slicer_download_token
			
 
				+
			
 
				+    cancel_signal = _FileCancelSignal(_job_cancel_path(job_id))
			
 
				+    status = PrinterFilesJobStatus(job_id, printer.id, "preparing", len(paths), filename=filename)
			
 
				+    await asyncio.to_thread(_write_job_status, status)
			
 
				+
			
 
				+    async def report_progress(successful: int, failed: int) -> None:
			
 
				+        await asyncio.to_thread(
			
 
				+            _write_job_status,
			
 
				+            PrinterFilesJobStatus(
			
 
				+                job_id,
			
 
				+                printer.id,
			
 
				+                "preparing",
			
 
				+                len(paths),
			
 
				+                successful=successful,
			
 
				+                failed=failed,
			
 
				+                filename=filename,
			
 
				+            ),
			
 
				+        )
			
 
				+
			
 
				+    try:
			
 
				+        async with asyncio.timeout(MAX_PRINTER_ZIP_PREPARE_SECONDS):
			
 
				+            if as_zip:
			
 
				+                result = await build_printer_files_zip(
			
 
				+                    printer,
			
 
				+                    paths,
			
 
				+                    sizes,
			
 
				+                    bundle_key=f"job-{job_id}",
			
 
				+                    cancel_signal=cancel_signal,
			
 
				+                    progress_callback=report_progress,
			
 
				+                )
			
 
				+            else:
			
 
				+                result = await build_printer_file(
			
 
				+                    printer,
			
 
				+                    paths[0],
			
 
				+                    sizes.get(paths[0]),
			
 
				+                    bundle_key=f"job-{job_id}",
			
 
				+                    cancel_signal=cancel_signal,
			
 
				+                )
			
 
				+        if cancel_signal.is_set():
			
 
				+            await asyncio.to_thread(remove_printer_files_zip, result.path)
			
 
				+            raise asyncio.CancelledError
			
 
				+        token = await create_slicer_download_token("printer-files", printer.id)
			
 
				+        if as_zip:
			
 
				+            result = await asyncio.to_thread(bind_printer_files_zip_to_token, result, printer.id, token)
			
 
				+        else:
			
 
				+            result = await asyncio.to_thread(bind_printer_file_to_token, result, printer.id, token)
			
 
				+        await asyncio.to_thread(
			
 
				+            _write_job_status,
			
 
				+            PrinterFilesJobStatus(
			
 
				+                job_id,
			
 
				+                printer.id,
			
 
				+                "ready",
			
 
				+                len(paths),
			
 
				+                successful=result.successful,
			
 
				+                failed=len(result.failed_paths),
			
 
				+                token=token,
			
 
				+                filename=filename,
			
 
				+            ),
			
 
				+        )
			
 
				+    except asyncio.CancelledError:
			
 
				+        await asyncio.shield(
			
 
				+            asyncio.to_thread(
			
 
				+                _write_job_status,
			
 
				+                PrinterFilesJobStatus(job_id, printer.id, "cancelled", len(paths), filename=filename),
			
 
				+            )
			
 
				+        )
			
 
				+    except PrinterFilesZipTooLargeError as exc:
			
 
				+        await asyncio.to_thread(
			
 
				+            _write_job_status,
			
 
				+            PrinterFilesJobStatus(job_id, printer.id, "failed", len(paths), filename=filename, message=str(exc)),
			
 
				+        )
			
 
				+    except PrinterFilesZipInsufficientSpaceError as exc:
			
 
				+        await asyncio.to_thread(
			
 
				+            _write_job_status,
			
 
				+            PrinterFilesJobStatus(job_id, printer.id, "failed", len(paths), filename=filename, message=str(exc)),
			
 
				+        )
			
 
				+    except TimeoutError:
			
 
				+        await asyncio.to_thread(
			
 
				+            _write_job_status,
			
 
				+            PrinterFilesJobStatus(
			
 
				+                job_id,
			
 
				+                printer.id,
			
 
				+                "failed",
			
 
				+                len(paths),
			
 
				+                filename=filename,
			
 
				+                message="Printer download preparation exceeded the 30-minute limit",
			
 
				+            ),
			
 
				+        )
			
 
				+    except FileNotFoundError as exc:
			
 
				+        await asyncio.to_thread(
			
 
				+            _write_job_status,
			
 
				+            PrinterFilesJobStatus(job_id, printer.id, "failed", len(paths), filename=filename, message=str(exc)),
			
 
				+        )
			
 
				+    except Exception:
			
 
				+        logger.exception("Printer download job %s failed", job_id)
			
 
				+        await asyncio.to_thread(
			
 
				+            _write_job_status,
			
 
				+            PrinterFilesJobStatus(
			
 
				+                job_id,
			
 
				+                printer.id,
			
 
				+                "failed",
			
 
				+                len(paths),
			
 
				+                filename=filename,
			
 
				+                message="Printer download preparation failed",
			
 
				+            ),
			
 
				+        )
			
 
				+    finally:
			
 
				+        await asyncio.to_thread(_job_cancel_path(job_id).unlink, missing_ok=True)
			
 
				+
			
 
				+
			
 
				+async def start_printer_files_job(
			
 
				+    printer,
			
 
				+    paths: list[str],
			
 
				+    sizes: dict[str, int],
			
 
				+    filename: str,
			
 
				+    *,
			
 
				+    as_zip: bool,
			
 
				+) -> PrinterFilesJobStatus:
			
 
				+    """Start a bounded background preparation and return immediately."""
			
 
				+
			
 
				+    if not paths:
			
 
				+        raise ValueError("No files specified")
			
 
				+    root = await asyncio.to_thread(_ensure_printer_zip_root)
			
 
				+    await asyncio.to_thread(_prune_stale_bundles, root)
			
 
				+    await asyncio.to_thread(_check_initial_space, root, sizes)
			
 
				+    job_id = secrets.token_urlsafe(24)
			
 
				+    status = PrinterFilesJobStatus(job_id, printer.id, "queued", len(paths), filename=filename)
			
 
				+    await asyncio.to_thread(_write_job_status, status)
			
 
				+    task = spawn_background_task(
			
 
				+        _run_printer_files_job(printer, job_id, paths, sizes, filename, as_zip),
			
 
				+        name=f"printer-download-{printer.id}-{job_id}",
			
 
				+    )
			
 
				+    _LOCAL_JOB_TASKS[job_id] = task
			
 
				+    task.add_done_callback(lambda _task: _LOCAL_JOB_TASKS.pop(job_id, None))
			
 
				+    return status
			
 
				+
			
 
				+
			
 
				+async def get_printer_files_job(job_id: str, printer_id: int) -> PrinterFilesJobStatus | None:
			
 
				+    status = await asyncio.to_thread(_read_job_status, job_id)
			
 
				+    if status is None or status.printer_id != printer_id:
			
 
				+        return None
			
 
				+    return status
			
 
				+
			
 
				+
			
 
				+async def cancel_printer_files_job(job_id: str, printer_id: int) -> bool:
			
 
				+    status = await get_printer_files_job(job_id, printer_id)
			
 
				+    if status is None:
			
 
				+        return False
			
 
				+    await asyncio.to_thread(_job_cancel_path(job_id).touch)
			
 
				+    task = _LOCAL_JOB_TASKS.get(job_id)
			
 
				+    if task is not None and not task.done():
			
 
				+        task.cancel()
			
 
				+    if status.state == "ready" and status.token:
			
 
				+        zip_path = printer_files_zip_path(printer_id, status.token)
			
 
				+        prepared = (
			
 
				+            zip_path
			
 
				+            if zip_path is not None and await asyncio.to_thread(zip_path.is_file)
			
 
				+            else printer_file_path(printer_id, status.token)
			
 
				+        )
			
 
				+        if prepared is not None:
			
 
				+            await asyncio.to_thread(remove_printer_files_zip, prepared)
			
 
				+        await asyncio.to_thread(
			
 
				+            _write_job_status,
			
 
				+            replace(status, state="cancelled", token=None),
			
 
				+        )
			
 
				+    return True
			
 
				+
			
 
				+
			
 
				+def remove_printer_files_zip(zip_path: Path) -> None:
			
 
				+    """Remove a completed download bundle after FileResponse finishes."""
			
 
				+
			
 
				+    shutil.rmtree(zip_path.parent, ignore_errors=True)
			
--- a/backend/app/services/slice_output_check.py
+++ b/backend/app/services/slice_output_check.py
@@ -11,6 +11,18 @@ so the only place to catch it is here, on the bytes the slicer just produced.
 
				 All 56 instantiable presets in the shipped Bambu bundle carry
			
 
				 ``gcode_claim_action``, which makes its absence a reliable signal rather than
			
 
				 a heuristic.
			
 
				+
			
 
				+``unresolved_filament_slots`` covers a quieter failure found while
			
 
				+investigating #2977: a filament profile whose name the sidecar's bundle
			
 
				+cannot resolve is not rejected. The CLI inherits nothing, falls back to its
			
 
				+compiled-in defaults for every field, and returns a perfectly well-formed
			
 
				+success. Measured against a 02.08.02.61 sidecar, a profile named for a preset
			
 
				+that does not exist slices as ``filament_type: ["PLA"]`` at
			
 
				+``nozzle_temperature: ["200"]`` with ``filament_ids: [""]`` and
			
 
				+``filament_vendor: ["(Undefined)"]`` — so a PETG preset that fails to resolve
			
 
				+prints at PLA temperatures. Unlike the missing start G-code this does not make
			
 
				+the file unprintable, only wrong, so it is reported as a warning and the slice
			
 
				+is kept.
			
 
				 """
			
 
				 
			
 
				 from __future__ import annotations
			
@@ -93,3 +105,73 @@ def missing_start_gcode_message(printer_preset_name: str) -> str:
 
				         "companion profile that holds the real start G-code for most Bambu printers. "
			
 
				         "Update the sidecar and slice again."
			
 
				     )
			
 
				+
			
 
				+
			
 
				+# What the CLI writes into a filament slot it could not resolve. Bambu Studio
			
 
				+# uses this literal for a filament whose vendor is unknown, and it is the one
			
 
				+# field that separates "nothing inherited" from a legitimately vendor-less
			
 
				+# profile: a resolved preset always carries a real ``filament_ids`` entry
			
 
				+# (``GFL96`` for Generic PLA Silk, ``GFG99`` for Generic PETG), while an
			
 
				+# unresolved one carries the empty string.
			
 
				+_UNDEFINED_VENDOR = "(Undefined)"
			
 
				+
			
 
				+
			
 
				+def unresolved_filament_slots(content: bytes, *, export_3mf: bool) -> list[int]:
			
 
				+    """1-indexed filament slots the slicer could not resolve a preset for.
			
 
				+
			
 
				+    Empty whenever the question cannot be settled — a raw-G-code response (the
			
 
				+    per-slot config only exists in the 3MF), an unreadable archive, a missing
			
 
				+    or malformed config. Same principle as ``start_gcode_is_missing``: a check
			
 
				+    that recognises one specific defect must not report anything it has not
			
 
				+    actually seen.
			
 
				+
			
 
				+    Both signals are required together. ``filament_vendor`` alone would flag a
			
 
				+    hand-written profile that simply never named a vendor, and ``filament_ids``
			
 
				+    alone would flag a user's own cloud preset, which legitimately carries no
			
 
				+    bundled filament id. A slot that has neither inherited a vendor nor been
			
 
				+    given an id is one where the ``inherits:`` target did not exist.
			
 
				+    """
			
 
				+    if not content or not export_3mf:
			
 
				+        return []
			
 
				+
			
 
				+    try:
			
 
				+        with zipfile.ZipFile(io.BytesIO(content)) as archive:
			
 
				+            raw = archive.read(_PROJECT_SETTINGS)
			
 
				+        settings = json.loads(raw)
			
 
				+    except (KeyError, OSError, zipfile.BadZipFile, UnicodeDecodeError, json.JSONDecodeError) as exc:
			
 
				+        logger.debug("Filament resolution check skipped: cannot read %s (%s)", _PROJECT_SETTINGS, exc)
			
 
				+        return []
			
 
				+
			
 
				+    if not isinstance(settings, dict):
			
 
				+        return []
			
 
				+    vendors = settings.get("filament_vendor")
			
 
				+    ids = settings.get("filament_ids")
			
 
				+    if not isinstance(vendors, list) or not isinstance(ids, list):
			
 
				+        logger.debug("Filament resolution check skipped: no per-slot vendor/id arrays")
			
 
				+        return []
			
 
				+
			
 
				+    unresolved: list[int] = []
			
 
				+    for slot in range(min(len(vendors), len(ids))):
			
 
				+        if _as_text(vendors[slot]).strip() == _UNDEFINED_VENDOR and not _as_text(ids[slot]).strip():
			
 
				+            unresolved.append(slot + 1)
			
 
				+    return unresolved
			
 
				+
			
 
				+
			
 
				+def unresolved_filament_message(slots: list[int], preset_names: list[str]) -> str:
			
 
				+    """The warning logged for slots whose filament preset did not resolve.
			
 
				+
			
 
				+    Names the presets by the slot they were picked for, because the user picked
			
 
				+    them per slot and that is the only handle they have on which dropdown to
			
 
				+    change.
			
 
				+    """
			
 
				+    parts: list[str] = []
			
 
				+    for slot in slots:
			
 
				+        name = preset_names[slot - 1] if slot - 1 < len(preset_names) else ""
			
 
				+        parts.append(f"slot {slot} ({name})" if name else f"slot {slot}")
			
 
				+    return (
			
 
				+        f"The slicer could not resolve the filament preset for {', '.join(parts)}, so those slots "
			
 
				+        "were sliced with its built-in defaults (PLA, 200 C) instead of the preset's own settings. "
			
 
				+        "The file was kept, but check the temperatures before printing. This usually means the "
			
 
				+        "slicer sidecar's bundled profiles do not contain the preset that was picked - updating "
			
 
				+        "the sidecar image, or picking a preset from its own bundled list, resolves it."
			
 
				+    )
			
--- a/backend/app/services/slicer_filament_resolver.py
+++ b/backend/app/services/slicer_filament_resolver.py
@@ -42,14 +42,34 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
				 from backend.app.models.user import User
			
 
				 from backend.app.utils.filament_ids import (
			
 
				     GENERIC_FILAMENT_IDS,
			
 
				-    MATERIAL_TEMPS,
			
 
				     filament_id_to_setting_id,
			
 
				     normalize_slicer_filament,
			
 
				 )
			
 
				+from backend.app.utils.filament_types import is_material_name
			
 
				 
			
 
				 logger = logging.getLogger(__name__)
			
 
				 
			
 
				-_KNOWN_MATERIALS = set(MATERIAL_TEMPS.keys()) | set(GENERIC_FILAMENT_IDS.keys())
			
 
				+
			
 
				+def _preset_filament_type(raw: object) -> str | None:
			
 
				+    """Read a slicer preset's ``filament_type`` field.
			
 
				+
			
 
				+    Bambu Studio and OrcaSlicer both store it as a one-element array
			
 
				+    (``["PLA"]``); some hand-written and older profiles store a bare string.
			
 
				+    ``orca_profiles._extract_filament_fields`` accepts both and this has to
			
 
				+    agree with it, since that is what fills ``LocalPreset.filament_type``.
			
 
				+
			
 
				+    The value is still run through ``printer_filament_type`` by the caller.
			
 
				+    That is a no-op for every type the app knows -- ``TestTheMaterialsBambuddyOffers``
			
 
				+    pins exactly that -- and a pass-through for a type it does not, so nothing
			
 
				+    the slicer says is discarded. It only bites on a hand-edited profile whose
			
 
				+    ``filament_type`` is a product line, which is the case this whole module
			
 
				+    exists to keep out of an AMS slot.
			
 
				+    """
			
 
				+    if isinstance(raw, list):
			
 
				+        raw = raw[0] if raw else None
			
 
				+    if isinstance(raw, str) and raw.strip():
			
 
				+        return raw.strip()
			
 
				+    return None
			
 
				 
			
 
				 
			
 
				 async def resolve_slicer_filament(
			
@@ -59,7 +79,7 @@ async def resolve_slicer_filament(
 
				     slicer_filament: str | None,
			
 
				     slicer_filament_name: str | None,
			
 
				     material: str | None,
			
 
				-) -> tuple[str, str, str | None]:
			
 
				+) -> tuple[str, str, str | None, str | None]:
			
 
				     """Resolve a spool's slicer-preset reference to printer-side ids.
			
 
				 
			
 
				     ``slicer_filament``: the spool's stored reference (e.g. ``"GFA01"``,
			
@@ -74,18 +94,30 @@ async def resolve_slicer_filament(
 
				     ``material``: spool material string for the local-preset fallback
			
 
				     branch when the LocalPreset's setting JSON doesn't carry a filament_id.
			
 
				 
			
 
				-    Returns ``(tray_info_idx, setting_id, sub_brand_override)`` — all empty
			
 
				-    when nothing resolved. ``sub_brand_override`` is non-None when a more
			
 
				-    specific brand label is available (cloud detail name or local preset
			
 
				+    Returns ``(tray_info_idx, setting_id, sub_brand_override, type_override)``
			
 
				+    — all empty when nothing resolved. ``sub_brand_override`` is non-None when
			
 
				+    a more specific brand label is available (cloud detail name or local preset
			
 
				     name); ``None`` means the caller should use its own default.
			
 
				+
			
 
				+    ``type_override`` is the preset's own ``filament_type`` when the preset
			
 
				+    carries one — the slicer's answer to what the material is, rather than one
			
 
				+    parsed out of the spool's material column. It is what the caller should
			
 
				+    write into ``tray_type``. ``None`` means no preset said, and the caller
			
 
				+    falls back to reducing the spool's material (``printer_filament_type``).
			
 
				+    Raised in the #2902 thread by @doncaruana: a preset has to be chosen from
			
 
				+    a list the slicer defines, so its type needs no interpreting. It cannot be
			
 
				+    the only source, though — ``slicer_filament`` is nullable on a spool while
			
 
				+    ``material`` is required, and the spool this issue was reported for had no
			
 
				+    preset at all.
			
 
				     """
			
 
				     sf = (slicer_filament or "").strip()
			
 
				     if not sf:
			
 
				-        return ("", "", None)
			
 
				+        return ("", "", None, None)
			
 
				 
			
 
				     tray_info_idx = ""
			
 
				     setting_id = ""
			
 
				     sub_brand_override: str | None = None
			
 
				+    type_override: str | None = None
			
 
				 
			
 
				     base_sf = sf.split("_")[0] if "_" in sf else sf
			
 
				 
			
@@ -106,6 +138,15 @@ async def resolve_slicer_filament(
 
				             if cloud is not None and cloud.is_authenticated:
			
 
				                 try:
			
 
				                     detail = await cloud.get_setting_detail(base_sf)
			
 
				+                    # The preset's own type, straight from the slicer's own
			
 
				+                    # profile -- no parsing of a product name (#2902). The
			
 
				+                    # preset JSON is nested under ``setting``; some responses
			
 
				+                    # carry it at the top level instead, the same shape spread
			
 
				+                    # ``preset_resolver`` documents.
			
 
				+                    cloud_setting = detail.get("setting")
			
 
				+                    type_override = _preset_filament_type(
			
 
				+                        (cloud_setting if isinstance(cloud_setting, dict) else detail).get("filament_type")
			
 
				+                    )
			
 
				                     if detail.get("filament_id"):
			
 
				                         tray_info_idx = detail["filament_id"]
			
 
				                         cloud_name = detail.get("name", "")
			
@@ -136,6 +177,10 @@ async def resolve_slicer_filament(
 
				             lp_result = await db.execute(select(LP).where(LP.id == local_id, LP.preset_type == "filament"))
			
 
				             lp = lp_result.scalar_one_or_none()
			
 
				             if lp:
			
 
				+                # The slicer's own answer, extracted from the profile at import
			
 
				+                # time by ``orca_profiles``. Preferred over anything parsed out
			
 
				+                # of the spool's material column (#2902).
			
 
				+                type_override = _preset_filament_type(lp.filament_type)
			
 
				                 # Local preset's setting JSON carries the printer-recognized
			
 
				                 # filament_id (e.g. "P4d64437") — use that directly so the
			
 
				                 # slicer can resolve the specific preset. Falls through to
			
@@ -153,6 +198,12 @@ async def resolve_slicer_filament(
 
				                     tray_info_idx = lp_filament_id
			
 
				                     setting_id = filament_id_to_setting_id(lp_filament_id)
			
 
				                 else:
			
 
				+                    # Deliberately not widened to cover product-line materials
			
 
				+                    # ("PLA+", "HTPLA") the way the callers' own fallbacks were
			
 
				+                    # (#2902). Returning an id here rather than "" would skip
			
 
				+                    # the caller's whole no-id block, and with it the slot-reuse
			
 
				+                    # branch that keeps a printer's calibrated preset -- so the
			
 
				+                    # widening belongs there, after reuse has had its turn.
			
 
				                     mat = (material or lp.filament_type or "").upper().strip()
			
 
				                     tray_info_idx = (
			
 
				                         GENERIC_FILAMENT_IDS.get(mat) or GENERIC_FILAMENT_IDS.get(mat.split("-")[0].split(" ")[0]) or ""
			
@@ -181,7 +232,9 @@ async def resolve_slicer_filament(
 
				     # material fallback can rescue the slot:
			
 
				     #   1. Literal material names ("PLA", "PETG-CF") that pass through
			
 
				     #      normalize_slicer_filament unchanged when the spool's slicer_filament
			
 
				-    #      is free-text rather than a real preset ID.
			
 
				+    #      is free-text rather than a real preset ID. Product lines ("PLA+",
			
 
				+    #      "HTPLA") count as material names too -- see is_material_name, which
			
 
				+    #      is shared with the slot-reuse check that must agree with this.
			
 
				     #   2. PFUS-prefix cloud setting_ids — valid as setting_id but rejected
			
 
				     #      by the slicer as tray_info_idx (the printer's calibration table
			
 
				     #      indexes by filament_id, and a PFUS isn't one). This normally gets
			
@@ -195,9 +248,7 @@ async def resolve_slicer_filament(
 
				     # Valid tray_info_idx values: "GF" + letter + digits (Bambu official) or
			
 
				     # "P" followed by hex (user/local presets, NOT "PFUS" or "PFCN").
			
 
				     if tray_info_idx and (
			
 
				-        tray_info_idx.upper() in _KNOWN_MATERIALS
			
 
				-        or tray_info_idx.startswith("PFUS")
			
 
				-        or tray_info_idx.startswith("PFCN")
			
 
				+        is_material_name(tray_info_idx) or tray_info_idx.startswith("PFUS") or tray_info_idx.startswith("PFCN")
			
 
				     ):
			
 
				         tray_info_idx = ""
			
 
				         # Preserve setting_id when it's still a valid slicer reference
			
@@ -215,4 +266,4 @@ async def resolve_slicer_filament(
 
				         ):
			
 
				             setting_id = ""
			
 
				 
			
 
				-    return (tray_info_idx, setting_id, sub_brand_override)
			
 
				+    return (tray_info_idx, setting_id, sub_brand_override, type_override)
			
--- a/backend/app/services/slot_kprofile.py
+++ b/backend/app/services/slot_kprofile.py
@@ -0,0 +1,189 @@
 
				+"""Find the stored K-profile for an AMS slot on a particular nozzle.
			
 
				+
			
 
				+K-profiles are per-nozzle: Bambuddy already keeps one row per
			
 
				+``(spool, printer, extruder)`` in ``spool_k_profile`` (and the Spoolman mirror
			
 
				+in ``spoolman_k_profile``), each with its own ``cali_idx`` and K value. On the
			
 
				+maintainer's H2C, one black PLA reads 0.018 on the left hotend and 0.020 on the
			
 
				+right, stored as calibration indices 16 and 15.
			
 
				+
			
 
				+A tray, by contrast, holds exactly **one** ``cali_idx``. So whenever a slot's
			
 
				+nozzle changes — which on a Filament Track Switch machine happens every time an
			
 
				+AMS is moved between the switch's two inlets — the stored counterpart for the
			
 
				+new nozzle has to be looked up and re-selected. This module is that lookup.
			
 
				+"""
			
 
				+
			
 
				+from dataclasses import dataclass
			
 
				+
			
 
				+from sqlalchemy import select
			
 
				+from sqlalchemy.ext.asyncio import AsyncSession
			
 
				+
			
 
				+from backend.app.models.spool import Spool
			
 
				+from backend.app.models.spool_assignment import SpoolAssignment
			
 
				+from backend.app.models.spool_k_profile import SpoolKProfile
			
 
				+from backend.app.models.spoolman_k_profile import SpoolmanKProfile
			
 
				+from backend.app.models.spoolman_slot_assignment import SpoolmanSlotAssignment
			
 
				+from backend.app.services.inventory_mode import spoolman_owns_assignments
			
 
				+from backend.app.services.spool_filament_preset import resolve_spool_preset, resolve_spoolman_preset
			
 
				+
			
 
				+
			
 
				+@dataclass(frozen=True)
			
 
				+class SlotKProfile:
			
 
				+    """A stored calibration profile, flattened across the two inventory backends."""
			
 
				+
			
 
				+    cali_idx: int | None
			
 
				+    k_value: float | None
			
 
				+    name: str | None
			
 
				+    extruder: int
			
 
				+    # The preset the profile was calibrated under. ``extrusion_cali_sel`` must
			
 
				+    # carry this rather than the tray's RFID value, or the firmware mislinks it.
			
 
				+    filament_id: str | None
			
 
				+
			
 
				+
			
 
				+def _flow_applies(stored_flow: str | None, fitted_flow: str | None) -> bool:
			
 
				+    """``SlotNozzle.flow_matches`` for callers that hold only the two strings."""
			
 
				+    from backend.app.services.slot_nozzle import SlotNozzle
			
 
				+
			
 
				+    return SlotNozzle(extruder=None, diameter="", flow=fitted_flow).flow_matches(stored_flow)
			
 
				+
			
 
				+
			
 
				+async def find_slot_kprofile_for_extruder(
			
 
				+    db: AsyncSession,
			
 
				+    printer_id: int,
			
 
				+    ams_id: int,
			
 
				+    tray_id: int,
			
 
				+    extruder: int,
			
 
				+    nozzle_diameter: str,
			
 
				+    printer_model: str | None = None,
			
 
				+    flow: str | None = None,
			
 
				+) -> SlotKProfile | None:
			
 
				+    """Stored profile for whatever is in this slot, calibrated for ``extruder``.
			
 
				+
			
 
				+    Returns None when the slot holds no known spool, or when that spool has no
			
 
				+    profile for this nozzle — an operator who calibrated only one side should
			
 
				+    keep the binding they set by hand rather than have it swapped for a guess.
			
 
				+
			
 
				+    Only the table the current inventory mode uses is consulted. Before #2812
			
 
				+    the inactive one was emptied on every mode toggle, so reading the built-in
			
 
				+    table first and stopping on a hit was safe -- there could be nothing in it
			
 
				+    to stop on. Nothing is emptied now, and a leftover built-in row would
			
 
				+    otherwise shadow the Spoolman assignment for the slot, returning that
			
 
				+    spool's profile or, on the deliberate stop below, no profile at all. That
			
 
				+    is the symptom #1556 reported from the other direction.
			
 
				+    """
			
 
				+    spoolman_mode = await spoolman_owns_assignments(db)
			
 
				+
			
 
				+    assignment = (
			
 
				+        None
			
 
				+        if spoolman_mode
			
 
				+        else (
			
 
				+            await db.execute(
			
 
				+                select(SpoolAssignment).where(
			
 
				+                    SpoolAssignment.printer_id == printer_id,
			
 
				+                    SpoolAssignment.ams_id == ams_id,
			
 
				+                    SpoolAssignment.tray_id == tray_id,
			
 
				+                )
			
 
				+            )
			
 
				+        ).scalar_one_or_none()
			
 
				+    )
			
 
				+
			
 
				+    if assignment is not None:
			
 
				+        profile = (
			
 
				+            (
			
 
				+                await db.execute(
			
 
				+                    select(SpoolKProfile).where(
			
 
				+                        SpoolKProfile.spool_id == assignment.spool_id,
			
 
				+                        SpoolKProfile.printer_id == printer_id,
			
 
				+                        SpoolKProfile.extruder == extruder,
			
 
				+                        SpoolKProfile.nozzle_diameter == nozzle_diameter,
			
 
				+                    )
			
 
				+                )
			
 
				+            )
			
 
				+            .scalars()
			
 
				+            .all()
			
 
				+        )
			
 
				+        # Flow is filtered here rather than in SQL: a stored NULL matches any
			
 
				+        # fitted nozzle (see SlotNozzle.flow_matches), which is not an equality
			
 
				+        # test and would need an OR IS NULL that reads worse than this.
			
 
				+        profile = next((p for p in profile if _flow_applies(p.nozzle_type, flow)), None)
			
 
				+        if profile is not None:
			
 
				+            spool = (await db.execute(select(Spool).where(Spool.id == assignment.spool_id))).scalar_one_or_none()
			
 
				+            # The preset this profile was calibrated under, through the
			
 
				+            # per-printer-model cascade: a spool can carry a different preset
			
 
				+            # per model, and extrusion_cali_sel has to name the one the printer
			
 
				+            # will actually see in the slot. Falls back to the spool's own
			
 
				+            # value when the caller cannot say which model this is.
			
 
				+            filament_id = spool.slicer_filament if spool else None
			
 
				+            if spool is not None and printer_model:
			
 
				+                filament_id, _ = await resolve_spool_preset(
			
 
				+                    db,
			
 
				+                    spool_id=spool.id,
			
 
				+                    printer_model=printer_model,
			
 
				+                    nozzle_diameter=nozzle_diameter,
			
 
				+                    fallback_filament=spool.slicer_filament,
			
 
				+                    fallback_name=spool.slicer_filament_name,
			
 
				+                )
			
 
				+            return SlotKProfile(
			
 
				+                cali_idx=profile.cali_idx,
			
 
				+                k_value=profile.k_value,
			
 
				+                name=profile.name,
			
 
				+                extruder=profile.extruder,
			
 
				+                filament_id=filament_id,
			
 
				+            )
			
 
				+        # A known spool with no profile for this nozzle is a deliberate stop:
			
 
				+        # falling through to Spoolman would answer for a different spool.
			
 
				+        return None
			
 
				+
			
 
				+    if not spoolman_mode:
			
 
				+        return None
			
 
				+
			
 
				+    sm_assignment = (
			
 
				+        await db.execute(
			
 
				+            select(SpoolmanSlotAssignment).where(
			
 
				+                SpoolmanSlotAssignment.printer_id == printer_id,
			
 
				+                SpoolmanSlotAssignment.ams_id == ams_id,
			
 
				+                SpoolmanSlotAssignment.tray_id == tray_id,
			
 
				+            )
			
 
				+        )
			
 
				+    ).scalar_one_or_none()
			
 
				+    if sm_assignment is None:
			
 
				+        return None
			
 
				+
			
 
				+    sm_profile = (
			
 
				+        (
			
 
				+            await db.execute(
			
 
				+                select(SpoolmanKProfile).where(
			
 
				+                    SpoolmanKProfile.spoolman_spool_id == sm_assignment.spoolman_spool_id,
			
 
				+                    SpoolmanKProfile.printer_id == printer_id,
			
 
				+                    SpoolmanKProfile.extruder == extruder,
			
 
				+                    SpoolmanKProfile.nozzle_diameter == nozzle_diameter,
			
 
				+                )
			
 
				+            )
			
 
				+        )
			
 
				+        .scalars()
			
 
				+        .all()
			
 
				+    )
			
 
				+    sm_profile = next((p for p in sm_profile if _flow_applies(p.nozzle_type, flow)), None)
			
 
				+    if sm_profile is None:
			
 
				+        return None
			
 
				+
			
 
				+    # A Spoolman K row carries no preset of its own, but the spool can still
			
 
				+    # have a per-model override stored locally -- that is the same table the
			
 
				+    # Spoolman assign path writes. Without a model to key on there is nothing
			
 
				+    # to resolve and the caller falls back to the tray's own tray_info_idx.
			
 
				+    sm_filament_id = None
			
 
				+    if printer_model:
			
 
				+        sm_filament_id, _ = await resolve_spoolman_preset(
			
 
				+            db,
			
 
				+            spoolman_spool_id=sm_assignment.spoolman_spool_id,
			
 
				+            printer_model=printer_model,
			
 
				+            nozzle_diameter=nozzle_diameter,
			
 
				+            fallback_filament=None,
			
 
				+            fallback_name=None,
			
 
				+        )
			
 
				+    return SlotKProfile(
			
 
				+        cali_idx=sm_profile.cali_idx,
			
 
				+        k_value=sm_profile.k_value,
			
 
				+        name=sm_profile.name,
			
 
				+        extruder=sm_profile.extruder,
			
 
				+        filament_id=sm_filament_id,
			
 
				+    )
			
--- a/backend/app/services/slot_nozzle.py
+++ b/backend/app/services/slot_nozzle.py
@@ -0,0 +1,179 @@
 
				+"""Which nozzle does this AMS slot feed, and how wide is it?
			
 
				+
			
 
				+Every path that configures a slot needs the same two facts: the extruder the
			
 
				+slot feeds, and that nozzle's diameter. Both the filament preset and the K
			
 
				+profile are stored per nozzle diameter, so getting the diameter wrong silently
			
 
				+selects the wrong preset *and* the wrong K value -- and before this module the
			
 
				+answer was worked out independently in seven places, each with ``nozzles[0]``
			
 
				+hard-coded as the diameter for every slot on the machine.
			
 
				+
			
 
				+``nozzles[0]`` is correct on a single-nozzle printer and correct on a
			
 
				+dual-nozzle printer with the same size fitted both sides, which is why it has
			
 
				+survived. It is wrong the moment someone fits a 0.4 and a 0.2, which is exactly
			
 
				+the machine this feature exists for.
			
 
				+
			
 
				+## Which array index belongs to which extruder
			
 
				+
			
 
				+``PrinterState.nozzles`` is filled by two different MQTT parsers that use
			
 
				+opposite conventions, and this module is where that is resolved once:
			
 
				+
			
 
				+* The **H2/X2 path** (``bambu_mqtt`` ~5100) writes ``nozzles[nozzle["id"]]``
			
 
				+  straight from ``device.nozzle.info``, i.e. indexed by physical nozzle id.
			
 
				+* The **legacy path** (~5013) writes left -> ``nozzles[0]``, right ->
			
 
				+  ``nozzles[1]``, which is the reverse of the extruder ids (extruder 0 is the
			
 
				+  RIGHT hotend).
			
 
				+
			
 
				+**MEASURED 2026-08-27 on an H2D with 0.4 high flow LEFT and 0.6 high flow
			
 
				+RIGHT: ``nozzles[0]`` read 0.6 -- the right hotend, which is extruder 0.** So
			
 
				+the array is indexed by extruder id, and the H2 convention (physical nozzle id N
			
 
				+sits on extruder N) is the one that holds.
			
 
				+
			
 
				+The legacy branch cannot govern a real dual-nozzle machine anyway: every model
			
 
				+in ``DUAL_NOZZLE_MODELS`` is H2-series or X2D, all of which report
			
 
				+``device.nozzle.info``, and ``left_nozzle_diameter`` appears nowhere in any
			
 
				+captured log or wire trace. On a single-nozzle printer both conventions agree
			
 
				+that index 0 is the only nozzle.
			
 
				+
			
 
				+The distinction is invisible on a machine with matching nozzles, since both
			
 
				+conventions then return the same string -- which is why it went unnoticed for so
			
 
				+long, and why this is the single place to change if a future model contradicts
			
 
				+it.
			
 
				+"""
			
 
				+
			
 
				+from __future__ import annotations
			
 
				+
			
 
				+import logging
			
 
				+from dataclasses import dataclass
			
 
				+
			
 
				+from backend.app.utils.fts_routing import slot_extruder
			
 
				+from backend.app.utils.printer_models import is_dual_nozzle_model
			
 
				+
			
 
				+logger = logging.getLogger(__name__)
			
 
				+
			
 
				+# What a printer that has told us nothing is assumed to have fitted. Matches
			
 
				+# the default every call site used before this module existed.
			
 
				+DEFAULT_NOZZLE_DIAMETER = "0.4"
			
 
				+
			
 
				+
			
 
				+@dataclass(frozen=True)
			
 
				+class SlotNozzle:
			
 
				+    """The nozzle an AMS slot feeds."""
			
 
				+
			
 
				+    # None when the printer has not said which extruder this slot feeds. Callers
			
 
				+    # that must have a number use ``extruder_or_default``; callers that store a
			
 
				+    # row keep the None so "unknown" is not written as "the right-hand nozzle".
			
 
				+    extruder: int | None
			
 
				+    diameter: str
			
 
				+    # "HH" (high flow), "HS" (standard), or None when the printer has not said.
			
 
				+    flow: str | None = None
			
 
				+
			
 
				+    @property
			
 
				+    def extruder_or_default(self) -> int:
			
 
				+        """0 when unknown -- correct on a single-nozzle machine, a guess on a dual."""
			
 
				+        return 0 if self.extruder is None else self.extruder
			
 
				+
			
 
				+    def flow_matches(self, stored_flow: str | None) -> bool:
			
 
				+        """Whether a stored K profile's flow type applies to this nozzle.
			
 
				+
			
 
				+        Unknown on either side matches anything, and that is the load-bearing
			
 
				+        case rather than a nicety:
			
 
				+
			
 
				+        * Every K profile stored before this existed has NULL here, so a strict
			
 
				+          comparison would stop applying all of them at once.
			
 
				+        * An X1C declares no flow on any calibration entry -- measured: all
			
 
				+          eight come back with ``nozzle_id: ''`` -- so profiles saved from one
			
 
				+          have nothing truthful to store. Treating "no answer" as "Standard"
			
 
				+          and then filtering on it would break the moment a high-flow nozzle is
			
 
				+          fitted to a machine whose table never mentioned flow.
			
 
				+
			
 
				+        Once BOTH sides do declare one, they have to agree: a K value measured
			
 
				+        on a high-flow nozzle is not a fact about a standard one, the same way
			
 
				+        a 0.6 measurement says nothing about a 0.4.
			
 
				+        """
			
 
				+        if not stored_flow or not self.flow:
			
 
				+            return True
			
 
				+        return normalise_flow(stored_flow) == self.flow
			
 
				+
			
 
				+
			
 
				+def normalise_flow(raw: str | None) -> str | None:
			
 
				+    """The flow-type code in a nozzle id or type string, or None.
			
 
				+
			
 
				+    Both spellings reduce to the same two letters, which is the whole point:
			
 
				+    a calibration entry files its nozzle as ``HH00-0.4`` / ``HS00-0.4`` while
			
 
				+    the fitted nozzle reports its type as ``HH01`` -- measured on an H2D, and
			
 
				+    the reason this compares two characters rather than four. The trailing
			
 
				+    digits are a hardware variant the calibration table normalises to ``00``.
			
 
				+    """
			
 
				+    text = (raw or "").strip().upper()
			
 
				+    return text[:2] if text[:2] in ("HH", "HS") else None
			
 
				+
			
 
				+
			
 
				+def nozzle_flow_for_extruder(state, extruder: int | None, model: str | None = None) -> str | None:
			
 
				+    """The flow type fitted to ``extruder``, or None when the printer is silent.
			
 
				+
			
 
				+    Read from the same array as the diameter and indexed the same way. A
			
 
				+    printer that reports no nozzle type -- an X1C sends none at all -- yields
			
 
				+    None, which ``flow_matches`` treats as "applies to anything" rather than
			
 
				+    inventing Standard.
			
 
				+    """
			
 
				+    nozzles = getattr(state, "nozzles", None) or []
			
 
				+    if not nozzles:
			
 
				+        return None
			
 
				+
			
 
				+    index = 0
			
 
				+    if extruder is not None and extruder > 0 and is_dual_nozzle_model(model):
			
 
				+        index = extruder
			
 
				+
			
 
				+    for candidate in (index, 0):
			
 
				+        if candidate < len(nozzles):
			
 
				+            flow = normalise_flow(getattr(nozzles[candidate], "nozzle_type", ""))
			
 
				+            if flow:
			
 
				+                return flow
			
 
				+    return None
			
 
				+
			
 
				+
			
 
				+def nozzle_diameter_for_extruder(state, extruder: int | None, model: str | None = None) -> str:
			
 
				+    """The diameter fitted to ``extruder``, or the printer's only nozzle.
			
 
				+
			
 
				+    Falls back to index 0, and then to 0.4, whenever the printer has not
			
 
				+    reported the entry -- an absent nozzle must not make this raise, since it is
			
 
				+    called on every assign.
			
 
				+    """
			
 
				+    nozzles = getattr(state, "nozzles", None) or []
			
 
				+    if not nozzles:
			
 
				+        return DEFAULT_NOZZLE_DIAMETER
			
 
				+
			
 
				+    index = 0
			
 
				+    if extruder is not None and extruder > 0 and is_dual_nozzle_model(model):
			
 
				+        # Physical nozzle id N sits on extruder N -- see the module docstring
			
 
				+        # for why the legacy left/right convention cannot apply here.
			
 
				+        index = extruder
			
 
				+
			
 
				+    for candidate in (index, 0):
			
 
				+        if candidate < len(nozzles):
			
 
				+            diameter = (getattr(nozzles[candidate], "nozzle_diameter", "") or "").strip()
			
 
				+            if diameter:
			
 
				+                return diameter
			
 
				+    return DEFAULT_NOZZLE_DIAMETER
			
 
				+
			
 
				+
			
 
				+def resolve_slot_nozzle(state, ams_id: int, tray_id: int, model: str | None = None) -> SlotNozzle:
			
 
				+    """The extruder an AMS slot feeds and that nozzle's diameter.
			
 
				+
			
 
				+    ``state`` is the live ``PrinterState`` (or None when the printer is not
			
 
				+    connected, which yields the defaults rather than an error).
			
 
				+    """
			
 
				+    if state is None:
			
 
				+        return SlotNozzle(extruder=None, diameter=DEFAULT_NOZZLE_DIAMETER)
			
 
				+
			
 
				+    extruder = slot_extruder(
			
 
				+        ams_id,
			
 
				+        tray_id,
			
 
				+        getattr(state, "ams_extruder_map", None),
			
 
				+        getattr(state, "ams_switch_inlet", None),
			
 
				+    )
			
 
				+    return SlotNozzle(
			
 
				+        extruder=extruder,
			
 
				+        diameter=nozzle_diameter_for_extruder(state, extruder, model),
			
 
				+        flow=nozzle_flow_for_extruder(state, extruder, model),
			
 
				+    )
			
--- a/backend/app/services/spool_assignment_notifications.py
+++ b/backend/app/services/spool_assignment_notifications.py
@@ -6,6 +6,7 @@ from backend.app.models.printer import Printer
 
				 from backend.app.models.spool_assignment import SpoolAssignment
			
 
				 from backend.app.models.spoolman_slot_assignment import SpoolmanSlotAssignment
			
 
				 from backend.app.services.bambu_mqtt import PrinterState
			
 
				+from backend.app.services.inventory_mode import spoolman_owns_assignments
			
 
				 from backend.app.services.notification_service import notification_service
			
 
				 from backend.app.services.printer_manager import printer_manager
			
 
				 
			
@@ -131,52 +132,94 @@ async def notify_missing_spool_assignments_on_print_start(
 
				             printer = await db.get(Printer, printer_id)
			
 
				             printer_name = printer.name if printer else f"Printer {printer_id}"
			
 
				 
			
 
				-            # A tray is "assigned" if it has a row in EITHER table: the legacy
			
 
				-            # spool_assignment table (internal-inventory mode) or
			
 
				-            # spoolman_slot_assignments (Spoolman mode — the binding
			
 
				-            # source-of-truth since #1119). Querying only the legacy table
			
 
				-            # flagged every used tray as missing on every Spoolman-mode print
			
 
				-            # (#1473). Both tables expose printer_id / ams_id / tray_id in the
			
 
				-            # same shape, so _global_tray_from_assignment works on either.
			
 
				-            legacy_rows = (
			
 
				-                await db.execute(SpoolAssignment.__table__.select().where(SpoolAssignment.printer_id == printer_id))
			
 
				-            ).fetchall()
			
 
				-            spoolman_rows = (
			
 
				-                await db.execute(
			
 
				-                    SpoolmanSlotAssignment.__table__.select().where(SpoolmanSlotAssignment.printer_id == printer_id)
			
 
				-                )
			
 
				-            ).fetchall()
			
 
				-            assigned_global_trays = {
			
 
				-                _global_tray_from_assignment(row.ams_id, row.tray_id) for row in (*legacy_rows, *spoolman_rows)
			
 
				-            }
			
 
				+            # A tray is "assigned" if it has a row in the table the current
			
 
				+            # mode uses. Both expose printer_id / ams_id / tray_id in the same
			
 
				+            # shape, so _global_tray_from_assignment works on either.
			
 
				+            #
			
 
				+            # This read both tables and unioned them until #2812. That was
			
 
				+            # correct while the inactive table was emptied on every mode
			
 
				+            # toggle -- it is how #1473 was fixed, where querying only the
			
 
				+            # legacy table flagged every tray as missing on a Spoolman print.
			
 
				+            # Nothing is emptied now, so a union would let a leftover row in
			
 
				+            # the mode you are *not* using vouch for a tray that has no
			
 
				+            # assignment in the mode you are, and this notification exists
			
 
				+            # precisely to catch that tray.
			
 
				+            table = SpoolmanSlotAssignment if await spoolman_owns_assignments(db) else SpoolAssignment
			
 
				+            rows = (await db.execute(table.__table__.select().where(table.printer_id == printer_id))).fetchall()
			
 
				+            assigned_global_trays = {_global_tray_from_assignment(row.ams_id, row.tray_id) for row in rows}
			
 
				 
			
 
				             missing_global = sorted(used_global_trays - assigned_global_trays)
			
 
				             if not missing_global:
			
 
				                 return
			
 
				 
			
 
				-            state = printer_manager.get_status(printer_id)
			
 
				-            missing_slots = []
			
 
				-            for global_id in missing_global:
			
 
				-                profile, color = _tray_profile_and_color_for_global_id(state, global_id)
			
 
				-                missing_slots.append(
			
 
				-                    {
			
 
				-                        "slot": _slot_label_from_global_tray(global_id),
			
 
				-                        "profile": profile,
			
 
				-                        "color": color,
			
 
				-                    }
			
 
				-                )
			
 
				-
			
 
				-            await ws_manager.send_missing_spool_assignment(
			
 
				-                printer_id=printer_id,
			
 
				-                printer_name=printer_name,
			
 
				-                missing_slots=missing_slots,
			
 
				-            )
			
 
				-
			
 
				-            await notification_service.on_print_missing_spool_assignment(
			
 
				-                printer_id=printer_id,
			
 
				-                printer_name=printer_name,
			
 
				-                missing_slots=missing_slots,
			
 
				-                db=db,
			
 
				-            )
			
 
				+            await _send_missing_assignment_notification(printer_id, printer_name, missing_global, db)
			
 
				     except Exception as e:
			
 
				         logger.warning("Missing spool-assignment notification failed: %s", e)
			
 
				+
			
 
				+
			
 
				+async def _send_missing_assignment_notification(
			
 
				+    printer_id: int,
			
 
				+    printer_name: str,
			
 
				+    missing_global: list[int],
			
 
				+    db,
			
 
				+) -> None:
			
 
				+    """Describe the unassigned trays and push them to the UI and the providers."""
			
 
				+    state = printer_manager.get_status(printer_id)
			
 
				+    missing_slots = []
			
 
				+    for global_id in missing_global:
			
 
				+        profile, color = _tray_profile_and_color_for_global_id(state, global_id)
			
 
				+        missing_slots.append(
			
 
				+            {
			
 
				+                "slot": _slot_label_from_global_tray(global_id),
			
 
				+                "profile": profile,
			
 
				+                "color": color,
			
 
				+            }
			
 
				+        )
			
 
				+
			
 
				+    await ws_manager.send_missing_spool_assignment(
			
 
				+        printer_id=printer_id,
			
 
				+        printer_name=printer_name,
			
 
				+        missing_slots=missing_slots,
			
 
				+    )
			
 
				+    await notification_service.on_print_missing_spool_assignment(
			
 
				+        printer_id=printer_id,
			
 
				+        printer_name=printer_name,
			
 
				+        missing_slots=missing_slots,
			
 
				+        db=db,
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+async def notify_missing_spool_assignments_on_print_complete(
			
 
				+    printer_id: int,
			
 
				+    missing_global_trays: list[int],
			
 
				+    db,
			
 
				+    logger: logging.Logger,
			
 
				+) -> None:
			
 
				+    """Say so when a finished print could not debit a tray it drew from (#2812).
			
 
				+
			
 
				+    The print-start check above is predictive: it reads the mapping before the
			
 
				+    job runs and warns about trays that have no assignment yet. It cannot cover
			
 
				+    an assignment that disappears *during* a print, and nothing re-checked
			
 
				+    afterwards -- so a print whose assignments existed at print start, and were
			
 
				+    gone by the time it finished, resolved its 3MF, resolved its grams,
			
 
				+    resolved its tray, skipped the debit at INFO, and reported success. The
			
 
				+    reporter lost 65.49 g that way and only noticed because a spool's remaining
			
 
				+    weight looked wrong.
			
 
				+
			
 
				+    This fires on realized loss rather than risk: the trays passed here are the
			
 
				+    ones a completed print actually tried to charge and could not. A print that
			
 
				+    was already warned at start will notify twice, which is the right trade --
			
 
				+    the first says the weight may not be tracked, the second says it was not.
			
 
				+
			
 
				+    Takes the caller's session: this runs inside ``on_print_complete``'s
			
 
				+    transaction, and opening a second one to read the printer's name would
			
 
				+    deadlock against it on SQLite.
			
 
				+    """
			
 
				+    if not missing_global_trays:
			
 
				+        return
			
 
				+    try:
			
 
				+        printer = await db.get(Printer, printer_id)
			
 
				+        printer_name = printer.name if printer else f"Printer {printer_id}"
			
 
				+        await _send_missing_assignment_notification(printer_id, printer_name, sorted(set(missing_global_trays)), db)
			
 
				+    except Exception as e:  # noqa: BLE001 — a notification must not fail a completed print
			
 
				+        logger.warning("Missing spool-assignment completion notification failed: %s", e)
			
--- a/backend/app/services/spool_filament_preset.py
+++ b/backend/app/services/spool_filament_preset.py
@@ -0,0 +1,127 @@
 
				+"""Resolve which slicer filament preset a spool should use on a given nozzle.
			
 
				+
			
 
				+``Spool.slicer_filament`` is the spool's single, printer-agnostic answer. It is
			
 
				+right until the same spool is used on two printer models, because a cloud or
			
 
				+Orca preset is bound to a model (``@BBL X1C``): assigning that spool to an H2C
			
 
				+writes a slot preset the H2C has no profile for. ``SpoolFilamentPreset`` stores
			
 
				+the per-model exceptions and this module is the only thing that reads them, so
			
 
				+the internal-inventory and Spoolman-inventory assign paths cannot drift apart
			
 
				+the way they did before #1713.
			
 
				+
			
 
				+Resolution order, most specific first:
			
 
				+
			
 
				+    1. (printer_model, nozzle_diameter)  -- what the spool form writes, one
			
 
				+                                            row per nozzle size
			
 
				+    2. (printer_model, "")               -- a whole-model value; the form does
			
 
				+                                            not write these, but the API accepts
			
 
				+                                            them and they still resolve
			
 
				+    3. ``Spool.slicer_filament``         -- what the spool carries today
			
 
				+
			
 
				+Every step is a plain equality match on stored strings; nothing is inferred
			
 
				+from preset names. A model with no row at all resolves to step 3, which is
			
 
				+exactly the behaviour every install has now, so a spool nobody has configured
			
 
				+per-model behaves identically before and after this feature.
			
 
				+"""
			
 
				+
			
 
				+from __future__ import annotations
			
 
				+
			
 
				+import logging
			
 
				+
			
 
				+from sqlalchemy import select
			
 
				+from sqlalchemy.ext.asyncio import AsyncSession
			
 
				+
			
 
				+from backend.app.models.spool_filament_preset import SpoolFilamentPreset, SpoolmanFilamentPreset
			
 
				+
			
 
				+logger = logging.getLogger(__name__)
			
 
				+
			
 
				+# What ``resolve_*`` returns: (slicer_filament, slicer_filament_name).
			
 
				+PresetPair = tuple[str | None, str | None]
			
 
				+
			
 
				+
			
 
				+def _pick(
			
 
				+    rows: list[SpoolFilamentPreset] | list[SpoolmanFilamentPreset],
			
 
				+    printer_model: str | None,
			
 
				+    nozzle_diameter: str | None,
			
 
				+    fallback: PresetPair,
			
 
				+) -> PresetPair:
			
 
				+    """Apply the cascade to rows already fetched for one spool.
			
 
				+
			
 
				+    Split out so both spool flavours share it, and so callers that already
			
 
				+    hold the rows (the spool form's read path) do not re-query.
			
 
				+    """
			
 
				+    model = (printer_model or "").strip()
			
 
				+    if not model:
			
 
				+        # No model means no way to be more specific than the spool's own value.
			
 
				+        # This is the normal answer for a printer that has not reported yet.
			
 
				+        return fallback
			
 
				+
			
 
				+    diameter = (nozzle_diameter or "").strip()
			
 
				+    exact: PresetPair | None = None
			
 
				+    model_default: PresetPair | None = None
			
 
				+
			
 
				+    for row in rows:
			
 
				+        if row.printer_model != model:
			
 
				+            continue
			
 
				+        if diameter and row.nozzle_diameter == diameter:
			
 
				+            exact = (row.slicer_filament, row.slicer_filament_name)
			
 
				+        elif row.nozzle_diameter == "":
			
 
				+            model_default = (row.slicer_filament, row.slicer_filament_name)
			
 
				+
			
 
				+    chosen = exact or model_default
			
 
				+    if chosen is None:
			
 
				+        return fallback
			
 
				+    # A row that exists but carries no preset id is a deliberate "use nothing
			
 
				+    # here", not a hole to fall through: the user picked the blank entry for
			
 
				+    # this model. Falling back would silently reinstate the value they cleared.
			
 
				+    return chosen
			
 
				+
			
 
				+
			
 
				+def printer_safe_filament_id(*candidates: str | None) -> str:
			
 
				+    """First candidate the printer will accept as a filament id, or "".
			
 
				+
			
 
				+    ``extrusion_cali_sel`` carries a filament id so the printer can link the
			
 
				+    calibration index to the slot's filament. A cloud USER preset id
			
 
				+    (``PFUS``/``PFCN`` prefix) is not one the slicer accepts -- the assign paths
			
 
				+    have refused those for tray_info_idx since #1713, and the same holds here.
			
 
				+
			
 
				+    This matters now that a per-model override can BE such an id: a user picking
			
 
				+    their own cloud preset for a model stores its ``PFUS...`` id, and passing
			
 
				+    that straight through would send the printer a value it rejects, silently
			
 
				+    losing the K-profile link. Falls through to the next candidate instead --
			
 
				+    normally the spool's own preset, then the tray's RFID value.
			
 
				+    """
			
 
				+    for candidate in candidates:
			
 
				+        value = (candidate or "").strip()
			
 
				+        if value and not value.startswith(("PFUS", "PFCN")):
			
 
				+            return value
			
 
				+    return ""
			
 
				+
			
 
				+
			
 
				+async def resolve_spool_preset(
			
 
				+    db: AsyncSession,
			
 
				+    *,
			
 
				+    spool_id: int,
			
 
				+    printer_model: str | None,
			
 
				+    nozzle_diameter: str | None,
			
 
				+    fallback_filament: str | None,
			
 
				+    fallback_name: str | None,
			
 
				+) -> PresetPair:
			
 
				+    """Cascade for an internal-inventory spool. See the module docstring."""
			
 
				+    result = await db.execute(select(SpoolFilamentPreset).where(SpoolFilamentPreset.spool_id == spool_id))
			
 
				+    return _pick(list(result.scalars().all()), printer_model, nozzle_diameter, (fallback_filament, fallback_name))
			
 
				+
			
 
				+
			
 
				+async def resolve_spoolman_preset(
			
 
				+    db: AsyncSession,
			
 
				+    *,
			
 
				+    spoolman_spool_id: int,
			
 
				+    printer_model: str | None,
			
 
				+    nozzle_diameter: str | None,
			
 
				+    fallback_filament: str | None,
			
 
				+    fallback_name: str | None,
			
 
				+) -> PresetPair:
			
 
				+    """Cascade for a Spoolman-managed spool. See the module docstring."""
			
 
				+    result = await db.execute(
			
 
				+        select(SpoolmanFilamentPreset).where(SpoolmanFilamentPreset.spoolman_spool_id == spoolman_spool_id)
			
 
				+    )
			
 
				+    return _pick(list(result.scalars().all()), printer_model, nozzle_diameter, (fallback_filament, fallback_name))
			
--- a/backend/app/services/spool_tag_matcher.py
+++ b/backend/app/services/spool_tag_matcher.py
@@ -8,6 +8,9 @@ from sqlalchemy.orm import selectinload
 
				 
			
 
				 from backend.app.models.spool import Spool
			
 
				 from backend.app.models.spool_assignment import SpoolAssignment
			
 
				+from backend.app.schemas.spool import normalize_effect_type
			
 
				+from backend.app.services.slot_nozzle import resolve_slot_nozzle
			
 
				+from backend.app.services.spool_filament_preset import printer_safe_filament_id, resolve_spool_preset
			
 
				 from backend.app.utils.tag_normalization import (
			
 
				     normalize_tag_uid as _normalize_tag_uid,
			
 
				     normalize_tray_uuid as _normalize_tray_uuid,
			
@@ -19,6 +22,13 @@ logger = logging.getLogger(__name__)
 
				 ZERO_TAG_UID = "0000000000000000"
			
 
				 ZERO_TRAY_UUID = "00000000000000000000000000000000"
			
 
				 
			
 
				+# Spool catalog row describing the reusable plastic spool Bambu Lab ships filament
			
 
				+# on, and the weight to assume when that row is absent. DEFAULT_SPOOL_CATALOG holds
			
 
				+# three "Bambu Lab%" rows (High Temp 216, Low Temp 250, White 253); this is the one
			
 
				+# that matches the spool an RFID roll actually arrives on.
			
 
				+BAMBU_PLASTIC_SPOOL_CATALOG_NAME = "Bambu Lab - Plastic Low Temp"
			
 
				+BAMBU_PLASTIC_SPOOL_CORE_WEIGHT = 250
			
 
				+
			
 
				 
			
 
				 def is_valid_tag(tag_uid: str, tray_uuid: str) -> bool:
			
 
				     """Check if a tag/UUID pair contains a non-zero, non-empty value."""
			
@@ -99,6 +109,8 @@ async def create_spool_from_tray(db: AsyncSession, tray_data: dict) -> Spool:
 
				     # PLA Basic happens to come first in catalog insertion order. See #1227.
			
 
				     rgba = tray_color if tray_color else None
			
 
				     color_name = None
			
 
				+    extra_colors = None
			
 
				+    effect_type = None
			
 
				 
			
 
				     # Transparent filament (#1545): the AMS reports alpha=00 for clear spools.
			
 
				     # Skip the catalog lookup — the catalog only stores RGB so 000000 would
			
@@ -124,6 +136,13 @@ async def create_spool_from_tray(db: AsyncSession, tray_data: dict) -> Spool:
 
				         entry = cat_result.scalar_one_or_none()
			
 
				         if entry:
			
 
				             color_name = entry.color_name
			
 
				+            # The same row the spool form's colour picker reads. It hands
			
 
				+            # `extra_colors` and `effect_type` to the new spool when a user
			
 
				+            # picks a colour by hand (ColorSection.selectColor), and this path
			
 
				+            # was taking the name alone -- so a roll added by hand rendered
			
 
				+            # its gradient and a roll the AMS identified for you did not.
			
 
				+            extra_colors = entry.extra_colors
			
 
				+            effect_type = entry.effect_type
			
 
				 
			
 
				     # If tray_id_name is a human-readable name (no "-" code), fall back to it.
			
 
				     if not color_name and tray_id_name and "-" not in tray_id_name:
			
@@ -136,13 +155,52 @@ async def create_spool_from_tray(db: AsyncSession, tray_data: dict) -> Spool:
 
				         color_name,
			
 
				     )
			
 
				 
			
 
				-    # Look up core weight from spool catalog
			
 
				-    core_weight = 250  # Default for Bambu Lab plastic spools
			
 
				-    cat_result = await db.execute(select(SpoolCatalogEntry).where(SpoolCatalogEntry.name.ilike("Bambu Lab%")).limit(10))
			
 
				-    for entry in cat_result.scalars().all():
			
 
				-        # Pick the best match (prefer exact, fallback to first Bambu Lab entry)
			
 
				-        core_weight = entry.weight
			
 
				-        break
			
 
				+    # Fall back to the subtype for the swatch's rendering hint. `effect_type`
			
 
				+    # is a visual variant kept independent of `subtype` so a user can override
			
 
				+    # how a roll is drawn without touching Bambu's categorical label -- but
			
 
				+    # nothing had ever set it here, and the shipped colour catalogue carries no
			
 
				+    # effect on any of its 600-odd rows, so in practice it was always NULL and
			
 
				+    # every wood, silk, sparkle and gradient roll drew as a flat disc. The
			
 
				+    # subtype is the answer where the catalogue has none: it is derived above
			
 
				+    # from what the printer reports, and the two vocabularies already line up
			
 
				+    # ("Wood", "Silk", "Dual Color" are values of both). A subtype that names
			
 
				+    # no effect -- Basic, Tough, CF -- leaves it NULL, which is the honest
			
 
				+    # answer rather than a guessed overlay.
			
 
				+    # "Silk+" is the same finish as "Silk" with a plus on the product name, so
			
 
				+    # the trailing sign is dropped on a second attempt rather than costing the
			
 
				+    # roll its overlay.
			
 
				+    if effect_type is None and subtype:
			
 
				+        for candidate in (subtype, subtype.rstrip("+")):
			
 
				+            try:
			
 
				+                effect_type = normalize_effect_type(candidate)
			
 
				+            except ValueError:
			
 
				+                continue
			
 
				+            break
			
 
				+
			
 
				+    # Look up core weight from the spool catalog by exact name. The previous
			
 
				+    # "Bambu Lab%" prefix query had no matching step and no ORDER BY, so it took
			
 
				+    # whichever of the three Bambu Lab rows the database returned first — High Temp
			
 
				+    # (216 g) on SQLite, undefined on Postgres once the table has seen updates.
			
 
				+    # core_weight is the tare in SpoolBuddy's weigh flow, so a wrong value here
			
 
				+    # silently biases every scale weighing of an RFID-created spool. See #2909.
			
 
				+    #
			
 
				+    # Falling back to the constant rather than to another catalog row keeps a
			
 
				+    # missing or renamed entry from reintroducing the arbitrary pick, and matching
			
 
				+    # by name means a user who has corrected that row to their own measurement gets
			
 
				+    # their value.
			
 
				+    core_weight = BAMBU_PLASTIC_SPOOL_CORE_WEIGHT
			
 
				+    core_weight_catalog_id = None
			
 
				+    cat_query = (
			
 
				+        select(SpoolCatalogEntry)
			
 
				+        .where(func.upper(SpoolCatalogEntry.name) == BAMBU_PLASTIC_SPOOL_CATALOG_NAME.upper())
			
 
				+        .order_by(SpoolCatalogEntry.id)
			
 
				+        .limit(1)
			
 
				+    )
			
 
				+    cat_result = await db.execute(cat_query)
			
 
				+    catalog_entry = cat_result.scalar_one_or_none()
			
 
				+    if catalog_entry:
			
 
				+        core_weight = catalog_entry.weight
			
 
				+        core_weight_catalog_id = catalog_entry.id
			
 
				 
			
 
				     # Resolve slicer filament name from builtin table
			
 
				     slicer_filament_name = None
			
@@ -173,9 +231,12 @@ async def create_spool_from_tray(db: AsyncSession, tray_data: dict) -> Spool:
 
				         subtype=subtype,
			
 
				         color_name=color_name,
			
 
				         rgba=rgba,
			
 
				+        extra_colors=extra_colors,
			
 
				+        effect_type=effect_type,
			
 
				         brand="Bambu Lab",
			
 
				         label_weight=label_weight,
			
 
				         core_weight=core_weight,
			
 
				+        core_weight_catalog_id=core_weight_catalog_id,
			
 
				         weight_used=weight_used,
			
 
				         slicer_filament=tray_info_idx or None,
			
 
				         slicer_filament_name=slicer_filament_name,
			
@@ -507,24 +568,49 @@ async def auto_assign_spool(
 
				     try:
			
 
				         client = printer_manager.get_client(printer_id)
			
 
				         if client:
			
 
				-            # Apply K-profile if available
			
 
				-            nozzle_diameter = "0.4"
			
 
				-            if state and state.nozzles:
			
 
				-                nd = state.nozzles[0].nozzle_diameter
			
 
				-                if nd:
			
 
				-                    nozzle_diameter = nd
			
 
				-
			
 
				-            matching_kp = None
			
 
				+            # Which nozzle this slot feeds, resolved the same way every other
			
 
				+            # slot-configuring path resolves it (services.slot_nozzle).
			
 
				+            slot_nozzle = resolve_slot_nozzle(state, ams_id, tray_id, printer_manager.get_model(printer_id))
			
 
				+            nozzle_diameter = slot_nozzle.diameter
			
 
				+
			
 
				+            # Prefer the profile calibrated for THIS hotend, falling back to one
			
 
				+            # stored for the same nozzle size on the other. Before this the
			
 
				+            # first row matching (printer, diameter) won outright with no
			
 
				+            # extruder test at all -- on a dual-nozzle printer that is a coin
			
 
				+            # toss between the two hotends, on the path that fires unattended
			
 
				+            # every time an RFID spool is loaded.
			
 
				+            exact_kp = None
			
 
				+            fallback_kp = None
			
 
				             for kp in spool.k_profiles:
			
 
				-                if kp.printer_id == printer_id and kp.nozzle_diameter == nozzle_diameter:
			
 
				-                    matching_kp = kp
			
 
				+                if kp.printer_id != printer_id or kp.nozzle_diameter != nozzle_diameter:
			
 
				+                    continue
			
 
				+                if not slot_nozzle.flow_matches(kp.nozzle_type):
			
 
				+                    continue
			
 
				+                if slot_nozzle.extruder is not None and kp.extruder == slot_nozzle.extruder:
			
 
				+                    exact_kp = kp
			
 
				                     break
			
 
				+                if fallback_kp is None:
			
 
				+                    fallback_kp = kp
			
 
				+            matching_kp = exact_kp or fallback_kp
			
 
				+
			
 
				+            # The id sent with extrusion_cali_sel has to name the preset the
			
 
				+            # profile was calibrated under, and that preset can differ per
			
 
				+            # printer model -- so it comes from the same cascade the assign
			
 
				+            # paths use rather than straight off the spool.
			
 
				+            model_filament, _ = await resolve_spool_preset(
			
 
				+                db,
			
 
				+                spool_id=spool.id,
			
 
				+                printer_model=printer_manager.get_model(printer_id),
			
 
				+                nozzle_diameter=nozzle_diameter,
			
 
				+                fallback_filament=spool.slicer_filament,
			
 
				+                fallback_name=spool.slicer_filament_name,
			
 
				+            )
			
 
				 
			
 
				             if matching_kp and matching_kp.cali_idx is not None:
			
 
				                 # The filament_id in extrusion_cali_sel must match the filament preset
			
 
				                 # under which the K-profile was calibrated. Use spool.slicer_filament
			
 
				                 # (the preset assigned in inventory), falling back to tray's RFID value.
			
 
				-                cali_filament_id = spool.slicer_filament or tray_info_idx or ""
			
 
				+                cali_filament_id = printer_safe_filament_id(model_filament, spool.slicer_filament, tray_info_idx)
			
 
				                 client.extrusion_cali_sel(
			
 
				                     ams_id=ams_id,
			
 
				                     tray_id=tray_id,
			
@@ -551,7 +637,7 @@ async def auto_assign_spool(
 
				                 # so the printer keeps its existing calibration selection.
			
 
				                 live_cali_idx = tray.get("cali_idx")
			
 
				                 if live_cali_idx is not None and live_cali_idx >= 0:
			
 
				-                    cali_filament_id = spool.slicer_filament or tray_info_idx or ""
			
 
				+                    cali_filament_id = printer_safe_filament_id(model_filament, spool.slicer_filament, tray_info_idx)
			
 
				                     client.extrusion_cali_sel(
			
 
				                         ams_id=ams_id,
			
 
				                         tray_id=tray_id,
			
--- a/backend/app/services/spoolman.py
+++ b/backend/app/services/spoolman.py
@@ -9,6 +9,8 @@ from typing import Literal
 
				 
			
 
				 import httpx
			
 
				 
			
 
				+from backend.app.utils.color_utils import color_match_key, spoolman_color_hex
			
 
				+
			
 
				 logger = logging.getLogger(__name__)
			
 
				 
			
 
				 BAMBU_RFID_TAG_LENGTH = 32
			
@@ -106,6 +108,18 @@ class SpoolmanClient:
 
				         # Per-spool locks for atomic read-modify-write in merge_spool_extra.
			
 
				         # WeakValueDictionary: locks are GC'd once no coroutine holds a reference.
			
 
				         self._extra_locks: weakref.WeakValueDictionary[int, asyncio.Lock] = weakref.WeakValueDictionary()
			
 
				+        # Extra-field names this client has already registered with Spoolman.
			
 
				+        # Bounded by the number of distinct keys Bambuddy writes, so it never
			
 
				+        # grows with spool count; scoped to the instance so a client pointed at
			
 
				+        # a different Spoolman starts over.
			
 
				+        self._ensured_extra_fields: set[str] = set()
			
 
				+        # Whether Spoolman's extra-field listing has been read once. Separate
			
 
				+        # from the set above because the two answer different questions: the
			
 
				+        # set is "which fields are known to exist", this is "have we asked".
			
 
				+        # Without it a client registering three brand-new fields re-read the
			
 
				+        # whole listing before each one.
			
 
				+        self._extra_fields_listed = False
			
 
				+        self._ensure_extra_lock = asyncio.Lock()
			
 
				 
			
 
				     async def _get_client(self) -> httpx.AsyncClient:
			
 
				         """Get or create the HTTP client with connection pooling limits."""
			
@@ -350,9 +364,10 @@ class SpoolmanClient:
 
				         if material:
			
 
				             data["material"] = material
			
 
				         if color_hex:
			
 
				-            # Strip alpha channel if present (RRGGBBAA -> RRGGBB)
			
 
				-            color_hex = color_hex[:6] if len(color_hex) >= 6 else color_hex
			
 
				-            data["color_hex"] = color_hex
			
 
				+            # Every create funnels through here, so this is where the stored shape
			
 
				+            # is decided: six characters for an opaque spool, eight only when the
			
 
				+            # alpha byte says the filament is translucent. See #2912.
			
 
				+            data["color_hex"] = spoolman_color_hex(color_hex) or color_hex
			
 
				         if color_name:
			
 
				             data["color_name"] = color_name
			
 
				         if weight:
			
@@ -403,6 +418,7 @@ class SpoolmanClient:
 
				             data["comment"] = comment
			
 
				         if extra:
			
 
				             data["extra"] = extra
			
 
				+            await self._ensure_extra_fields(extra)
			
 
				 
			
 
				         logger.debug("Creating spool in Spoolman: %s", data)
			
 
				         try:
			
@@ -443,6 +459,7 @@ class SpoolmanClient:
 
				             data["location"] = location
			
 
				         if extra:
			
 
				             data["extra"] = extra
			
 
				+            await self._ensure_extra_fields(extra)
			
 
				         data["last_used"] = datetime.now(timezone.utc).isoformat()
			
 
				 
			
 
				         response = await self._request_spool("PATCH", spool_id, json_body=data, operation="update")
			
@@ -700,6 +717,7 @@ class SpoolmanClient:
 
				             data["location"] = location
			
 
				         if extra is not None:
			
 
				             data["extra"] = extra
			
 
				+            await self._ensure_extra_fields(extra)
			
 
				         if clear_spool_weight:
			
 
				             data["spool_weight"] = None
			
 
				         elif spool_weight is not None:
			
@@ -748,7 +766,12 @@ class SpoolmanClient:
 
				     ) -> int:
			
 
				         """Return the filament ID matching material/name/brand/color, creating it if absent."""
			
 
				         name = f"{material} {subtype}".strip() if subtype else material
			
 
				-        color = color_hex[:6].upper() if len(color_hex) >= 6 else color_hex.upper()
			
 
				+        # One value in both roles. `color_match_key` returns the shape the colour
			
 
				+        # would be stored as, so the key the loop below compares on and the value
			
 
				+        # a new filament is created with are the same string by construction: an
			
 
				+        # opaque spool keys and stores as six characters, a translucent one as
			
 
				+        # eight, and neither can be conflated with the other (#2912).
			
 
				+        color = color_match_key(color_hex)
			
 
				 
			
 
				         vendor_id: int | None = None
			
 
				         if brand:
			
@@ -763,7 +786,7 @@ class SpoolmanClient:
 
				         filaments = await self.get_filaments()
			
 
				         for f in filaments:
			
 
				             f_material = (f.get("material") or "").upper()
			
 
				-            f_color = (f.get("color_hex") or "").upper()[:6]
			
 
				+            f_color = color_match_key(f.get("color_hex"))
			
 
				             f_vendor = f.get("vendor") or {}
			
 
				             f_vendor_name = (f_vendor.get("name") or "").strip().lower()
			
 
				 
			
@@ -936,6 +959,36 @@ class SpoolmanClient:
 
				         """Register the 'tag' extra field in Spoolman if not present; returns True on success."""
			
 
				         return await self.ensure_extra_field("tag")
			
 
				 
			
 
				+    async def _load_existing_extra_field_keys(self) -> set[str] | None:
			
 
				+        """Keys of the spool extra fields Spoolman already has, or ``None`` when
			
 
				+        the listing could not be read.
			
 
				+
			
 
				+        ``None`` and ``set()`` mean different things and the caller acts on the
			
 
				+        difference: an empty set is "Spoolman has no extra fields", which means
			
 
				+        every field Bambuddy needs must be created; ``None`` is "we could not
			
 
				+        find out", where the only safe move is to fall back to attempting the
			
 
				+        write blind.
			
 
				+        """
			
 
				+        try:
			
 
				+            client = await self._get_client()
			
 
				+            response = await client.get(f"{self.api_url}/field/spool")
			
 
				+            if response.status_code != 200:
			
 
				+                logger.debug(
			
 
				+                    "Spoolman extra-field listing returned %s; falling back to blind registration",
			
 
				+                    response.status_code,
			
 
				+                )
			
 
				+                return None
			
 
				+            fields = response.json()
			
 
				+        except Exception as e:  # noqa: BLE001 — registration is best-effort, see _ensure_extra_fields
			
 
				+            logger.debug("Could not read Spoolman extra-field listing: %s", e)
			
 
				+            return None
			
 
				+        if not isinstance(fields, list):
			
 
				+            return None
			
 
				+        # Match on `key`, not `name`: `key` is the identifier the extra dict is
			
 
				+        # written under and the one Bambuddy cares about, while `name` is the
			
 
				+        # free-text label a user is free to change in Spoolman's UI.
			
 
				+        return {f["key"] for f in fields if isinstance(f, dict) and isinstance(f.get("key"), str)}
			
 
				+
			
 
				     async def ensure_extra_field(self, name: str, field_type: str = "text") -> bool:
			
 
				         """Register a custom extra field in Spoolman if not present.
			
 
				 
			
@@ -943,17 +996,40 @@ class SpoolmanClient:
 
				         with HTTP 400 ('Unknown extra field <name>.'), so any custom field
			
 
				         Bambuddy persists alongside spools needs to be pre-registered.
			
 
				         Idempotent — returns True if the field already exists.
			
 
				+
			
 
				+        Existence is read from ``GET /field/spool``, the whole-listing endpoint.
			
 
				+        This used to probe ``GET /field/spool/{name}`` for one field at a time,
			
 
				+        which Spoolman has never served: it declares only POST and DELETE at
			
 
				+        that path, so the probe answered 405 every time and the check could
			
 
				+        never succeed (issue #2983, reported by @ngreatorex).
			
 
				+
			
 
				+        Falling through to the POST on every call was worse than a wasted
			
 
				+        request, because that endpoint is an upsert rather than a create. It
			
 
				+        answered 200 whether or not the field was already there, so a field a
			
 
				+        user had renamed, retyped or given a default in Spoolman's own UI was
			
 
				+        silently reset to Bambuddy's version of it on every restart. Reading
			
 
				+        the listing first is what lets an existing field be left alone.
			
 
				         """
			
 
				         try:
			
 
				-            client = await self._get_client()
			
 
				-
			
 
				-            # Check if field already exists
			
 
				-            response = await client.get(f"{self.api_url}/field/spool/{name}")
			
 
				-            if response.status_code == 200:
			
 
				-                logger.debug("Spoolman extra field %r already exists", name)
			
 
				+            if name in self._ensured_extra_fields:
			
 
				                 return True
			
 
				 
			
 
				-            # Field doesn't exist - create it
			
 
				+            if not self._extra_fields_listed:
			
 
				+                existing = await self._load_existing_extra_field_keys()
			
 
				+                if existing is not None:
			
 
				+                    # Bank the whole listing: the caller registers several
			
 
				+                    # fields in a row, and each one it already has is a request
			
 
				+                    # not sent and a user customisation not overwritten. Read
			
 
				+                    # once per client — every field created after this point is
			
 
				+                    # added to the set as it is created, so re-reading would
			
 
				+                    # only ever confirm what we already know.
			
 
				+                    self._ensured_extra_fields |= existing
			
 
				+                    self._extra_fields_listed = True
			
 
				+                    if name in existing:
			
 
				+                        logger.debug("Spoolman extra field %r already exists", name)
			
 
				+                        return True
			
 
				+
			
 
				+            client = await self._get_client()
			
 
				             field_data = {
			
 
				                 "name": name,
			
 
				                 "field_type": field_type,
			
@@ -962,6 +1038,7 @@ class SpoolmanClient:
 
				             response = await client.post(f"{self.api_url}/field/spool/{name}", json=field_data)
			
 
				             if response.status_code in (200, 201):
			
 
				                 logger.info("Created Spoolman extra field %r", name)
			
 
				+                self._ensured_extra_fields.add(name)
			
 
				                 return True
			
 
				 
			
 
				             logger.warning(
			
@@ -976,6 +1053,43 @@ class SpoolmanClient:
 
				             logger.warning("Failed to ensure Spoolman extra field %r exists: %s", name, e)
			
 
				             return False
			
 
				 
			
 
				+    async def _ensure_extra_fields(self, extra: dict | None) -> None:
			
 
				+        """Register every extra key an outgoing write declares, once per client.
			
 
				+
			
 
				+        Spoolman answers HTTP 400 "Unknown extra field <name>." for any extra
			
 
				+        key that was not registered first, so registration has to happen before
			
 
				+        the write, not before the feature. It used to happen before the feature:
			
 
				+        three hand-maintained lists (the connect route, startup, and two inline
			
 
				+        blocks in the inventory routes) each named the fields they expected to
			
 
				+        be written later. Enabling Spoolman from Settings reaches none of them,
			
 
				+        so the first AMS sync on a fresh Spoolman failed on every slot -- and
			
 
				+        the Connect button that would have registered them is hidden by then,
			
 
				+        because saving the settings initialises the client and the status
			
 
				+        endpoint reads that as "connected" (issue #2903).
			
 
				+
			
 
				+        Keying off the payload instead removes the chance to forget: a write
			
 
				+        that carries a key is a write that registers it. ``bambu_color_name``
			
 
				+        is the cautionary case -- it never made it into the connect or startup
			
 
				+        lists, and only works today because two call sites remembered to
			
 
				+        register it by hand.
			
 
				+
			
 
				+        Best-effort by design. ``ensure_extra_field`` logs and returns False
			
 
				+        rather than raising, and a failure here must not turn a write that
			
 
				+        might still succeed into one that never happens -- the caller's own
			
 
				+        error handling stays exactly as it was.
			
 
				+        """
			
 
				+        names = [name for name in (extra or {}) if name not in self._ensured_extra_fields]
			
 
				+        if not names:
			
 
				+            return
			
 
				+
			
 
				+        async with self._ensure_extra_lock:
			
 
				+            for name in names:
			
 
				+                # Re-check under the lock: a concurrent write may have just
			
 
				+                # registered this one, and two syncs racing to POST the same
			
 
				+                # field is how one of them gets a needless warning logged.
			
 
				+                if name not in self._ensured_extra_fields:
			
 
				+                    await self.ensure_extra_field(name)
			
 
				+
			
 
				     def parse_ams_tray(self, ams_id: int, tray_data: dict) -> AMSTray | None:
			
 
				         """Parse raw MQTT tray data into an AMSTray; returns None for empty or invalid trays."""
			
 
				         # Skip empty trays - check for valid tray_type
			
@@ -1151,7 +1265,7 @@ class SpoolmanClient:
 
				                         material=tray.tray_type,
			
 
				                         subtype="",
			
 
				                         brand=brand,
			
 
				-                        color_hex=tray.tray_color[:6],
			
 
				+                        color_hex=tray.tray_color,
			
 
				                         label_weight=tray.tray_weight,
			
 
				                     )
			
 
				                 except (SpoolmanNotFoundError, SpoolmanUnavailableError, SpoolmanClientError):
			
@@ -1201,9 +1315,12 @@ class SpoolmanClient:
 
				     async def _find_or_create_filament(self, tray: AMSTray) -> dict | None:
			
 
				         """Return a Bambu Lab filament matching the tray's material/color, creating it if absent."""
			
 
				         bambu_vendor_id = await self.ensure_bambu_vendor()
			
 
				-        color_hex = tray.tray_color[:6]  # Strip alpha channel
			
 
				         material_upper = tray.tray_type.upper()
			
 
				-        color_upper = color_hex.upper()
			
 
				+        # Same single value as the user-driven path: the match key is the stored
			
 
				+        # shape. That is what lets an opaque tray still find the six-character
			
 
				+        # filaments every existing instance is full of, while a clear tray keys
			
 
				+        # to eight and gets its own record (#2912).
			
 
				+        color = color_match_key(tray.tray_color)
			
 
				 
			
 
				         # Search internal filaments - only match Bambu Lab vendor
			
 
				         filaments = await self.get_filaments()
			
@@ -1212,8 +1329,7 @@ class SpoolmanClient:
 
				             if fil_vendor_id != bambu_vendor_id:
			
 
				                 continue
			
 
				             fil_material = filament.get("material") or ""
			
 
				-            fil_color = filament.get("color_hex") or ""
			
 
				-            if fil_material.upper() == material_upper and fil_color.upper() == color_upper:
			
 
				+            if fil_material.upper() == material_upper and color_match_key(filament.get("color_hex")) == color:
			
 
				                 return filament
			
 
				 
			
 
				         # Search external filaments (SpoolmanDB) — restrict to Bambu Lab only.
			
@@ -1229,8 +1345,7 @@ class SpoolmanClient:
 
				             if manufacturer != "bambu lab" and not ext_id.startswith("bambulab_"):
			
 
				                 continue
			
 
				             fil_material = filament.get("material") or ""
			
 
				-            fil_color = filament.get("color_hex") or ""
			
 
				-            if fil_material.upper() == material_upper and fil_color.upper() == color_upper:
			
 
				+            if fil_material.upper() == material_upper and color_match_key(filament.get("color_hex")) == color:
			
 
				                 bambu_candidates.append(filament)
			
 
				 
			
 
				         if bambu_candidates:
			
@@ -1248,7 +1363,7 @@ class SpoolmanClient:
 
				             name=tray.tray_sub_brands or tray.tray_type,
			
 
				             vendor_id=bambu_vendor_id,
			
 
				             material=tray.tray_type,
			
 
				-            color_hex=color_hex,
			
 
				+            color_hex=color,
			
 
				             weight=tray.tray_weight,
			
 
				         )
			
 
				 
			
@@ -1259,7 +1374,11 @@ class SpoolmanClient:
 
				             name=external.get("name", tray.tray_sub_brands),
			
 
				             vendor_id=vendor_id,
			
 
				             material=external.get("material", tray.tray_type),
			
 
				-            color_hex=external.get("color_hex", tray.tray_color[:6]),
			
 
				+            # `or`, not a two-argument get: an entry that carries the key with an
			
 
				+            # explicit null would hand None to create_filament rather than reach
			
 
				+            # the tray fallback. Only a candidate when the tray colour is empty
			
 
				+            # too, so this is a correctness tidy, not a fix for a live path.
			
 
				+            color_hex=external.get("color_hex") or color_match_key(tray.tray_color),
			
 
				             weight=external.get("weight", tray.tray_weight),
			
 
				             density=external.get("density"),
			
 
				         )
			
--- a/backend/app/services/spoolman_tracking.py
+++ b/backend/app/services/spoolman_tracking.py
@@ -7,6 +7,8 @@ Supports accurate partial usage reporting for failed/cancelled prints.
 
				 
			
 
				 import json
			
 
				 import logging
			
 
				+import math
			
 
				+from dataclasses import dataclass
			
 
				 
			
 
				 from sqlalchemy import delete, select
			
 
				 
			
@@ -40,6 +42,11 @@ _ZERO_TAG_UID = "0000000000000000"
 
				 _MAX_REAL_TRAY_ID = 254
			
 
				 
			
 
				 
			
 
				+def _is_real_tray_id(value) -> bool:
			
 
				+    """True when ``value`` names a physical slot rather than "nothing loaded"."""
			
 
				+    return isinstance(value, int) and not isinstance(value, bool) and 0 <= value <= _MAX_REAL_TRAY_ID
			
 
				+
			
 
				+
			
 
				 def _is_non_zero_identifier(value: str) -> bool:
			
 
				     """Return True when identifier is non-empty and not all zeros."""
			
 
				     if not value:
			
@@ -163,7 +170,73 @@ def _resolve_global_tray_id(slot_id: int, slot_to_tray: list | None, ams_trays:
 
				     return slot_id - 1
			
 
				 
			
 
				 
			
 
				-def _resolve_slot_to_tray_fallback(printer_id: int, filament_usage: list[dict]) -> tuple[list[int] | None, str]:
			
 
				+def _single_slot_tray_from_state(
			
 
				+    state,
			
 
				+    filament_usage: list[dict],
			
 
				+    tray_now_at_start: int | None = None,
			
 
				+) -> tuple[int, int] | None:
			
 
				+    """The tray a single-slot print actually drew from, read off the printer.
			
 
				+
			
 
				+    A1, A1 mini, P1S and P2S publish no ``mapping`` field and drop the MQTT
			
 
				+    connection when we subscribe to their request topic, so neither of the
			
 
				+    other two fallbacks can answer for them. What they do report is which tray
			
 
				+    the extruder is fed from, and for a print that uses exactly one filament
			
 
				+    slot that is the same question: the one slot came from the one tray.
			
 
				+
			
 
				+    The ladder mirrors ``usage_tracker.on_print_complete`` step 5, which has
			
 
				+    consulted these same fields since it started resolving mappings at
			
 
				+    completion. Spoolman users were the only ones not getting them (#2953).
			
 
				+
			
 
				+    Gated on exactly one slot with usage, like the internal writer: on a
			
 
				+    multi-colour print every filament change moves ``tray_now``, so a single
			
 
				+    tray reading says nothing about which slot it belongs to.
			
 
				+
			
 
				+    More than one tray-change entry means the print switched trays mid-run
			
 
				+    (AMS backup on runout, #957). ``report_usage`` splits those per segment
			
 
				+    and must not be handed a single-tray mapping instead, so this declines.
			
 
				+
			
 
				+    Returns ``(slot_id, global_tray_id)``, or None when the printer offered no
			
 
				+    usable reading and the positional default stands.
			
 
				+    """
			
 
				+    nonzero = [u for u in filament_usage or [] if u.get("used_g", 0) > 0]
			
 
				+    if len(nonzero) != 1:
			
 
				+        return None
			
 
				+    slot_id = nonzero[0].get("slot_id", 0)
			
 
				+    if slot_id <= 0:
			
 
				+        return None
			
 
				+
			
 
				+    changes = list(getattr(state, "tray_change_log", None) or [])
			
 
				+    if len(changes) > 1:
			
 
				+        return None
			
 
				+    if len(changes) == 1:
			
 
				+        entry = changes[0]
			
 
				+        if isinstance(entry, (tuple, list)) and entry and _is_real_tray_id(entry[0]):
			
 
				+            # Strongest evidence there is: the printer announced this switch
			
 
				+            # while the job was running, so it describes this print and no
			
 
				+            # other. On the reporter's A1 it read (3, 0) -- tray 3 at layer 0
			
 
				+            # -- while the positional default was charging tray 0.
			
 
				+            return slot_id, entry[0]
			
 
				+
			
 
				+    # No mid-print switch recorded. Fall back to the standing tray readings,
			
 
				+    # newest evidence first. ``tray_now`` is 255 both at rest and while
			
 
				+    # nothing is loaded, which is why _MAX_REAL_TRAY_ID excludes it; A1
			
 
				+    # firmware parks there the moment a print ends, leaving last_loaded_tray
			
 
				+    # as the only survivor.
			
 
				+    for candidate in (
			
 
				+        tray_now_at_start,
			
 
				+        getattr(state, "tray_now", None),
			
 
				+        getattr(state, "last_loaded_tray", None),
			
 
				+    ):
			
 
				+        if _is_real_tray_id(candidate):
			
 
				+            return slot_id, candidate
			
 
				+    return None
			
 
				+
			
 
				+
			
 
				+def _resolve_slot_to_tray_fallback(
			
 
				+    printer_id: int,
			
 
				+    filament_usage: list[dict],
			
 
				+    tray_now_at_start: int | None = None,
			
 
				+) -> tuple[list[int] | None, str]:
			
 
				     """Recover a slot-to-tray mapping at completion when print start captured none.
			
 
				 
			
 
				     ``store_print_data`` can only learn the mapping from two sources: the
			
@@ -180,9 +253,17 @@ def _resolve_slot_to_tray_fallback(printer_id: int, filament_usage: list[dict])
 
				     The printer knows the real answer. Its ``mapping`` field carries the actual
			
 
				     slot-to-tray assignment for the running job, and for the models that never
			
 
				     publish it (A1, P1S, P2S) the 3MF's per-slot colours can be matched against
			
 
				-    the loaded trays instead. The built-in inventory writer has consulted both
			
 
				-    for as long as it has resolved mappings at completion; this gives the
			
 
				-    Spoolman writer the same two fallbacks at the same moment.
			
 
				+    the loaded trays instead. Failing both, a print that used a single filament
			
 
				+    slot can be pinned to the tray the printer reported feeding from
			
 
				+    (``_single_slot_tray_from_state``).
			
 
				+
			
 
				+    The built-in inventory writer has consulted all three for as long as it has
			
 
				+    resolved mappings at completion. The first version of this function offered
			
 
				+    only the first two, which left A1-class printers -- no ``mapping`` field, no
			
 
				+    request topic -- with nothing but the colour match, and that needs the
			
 
				+    slicer's filament colour to equal the tray's exactly. A generic black
			
 
				+    profile against a tray set to #111111 does not match, and the print is
			
 
				+    charged to whichever spool happens to sit in the first tray (#2953).
			
 
				 
			
 
				     Deliberately at completion rather than inside ``store_print_data``: the
			
 
				     printer keeps publishing ``mapping`` long after a job ends — it is still in
			
@@ -193,28 +274,46 @@ def _resolve_slot_to_tray_fallback(printer_id: int, filament_usage: list[dict])
 
				 
			
 
				     Args:
			
 
				         printer_id: Printer whose live state is consulted.
			
 
				-        filament_usage: The 3MF's per-slot estimates, needed by the colour
			
 
				-            match. Only the ``slot_id``/``color`` keys are read.
			
 
				+        filament_usage: The 3MF's per-slot estimates. The colour match reads
			
 
				+            ``slot_id``/``color``; the tray-state fallback reads
			
 
				+            ``slot_id``/``used_g``.
			
 
				+        tray_now_at_start: The tray the printer was feeding from when the print
			
 
				+            began, as captured by ``store_print_data``. Only consulted by the
			
 
				+            tray-state fallback.
			
 
				 
			
 
				     Returns:
			
 
				-        ``(mapping, source)``, or ``(None, "none")`` when neither fallback
			
 
				-        produced anything and the positional default stands.
			
 
				+        ``(mapping, source)``, or ``(None, "none")`` when no fallback produced
			
 
				+        anything and the positional default stands.
			
 
				     """
			
 
				     from backend.app.services.printer_manager import printer_manager
			
 
				     from backend.app.services.usage_tracker import _decode_mqtt_mapping, _match_slots_by_color
			
 
				 
			
 
				     state = printer_manager.get_status(printer_id)
			
 
				     raw_data = getattr(state, "raw_data", None) if state else None
			
 
				-    if not raw_data:
			
 
				-        return None, "none"
			
 
				-
			
 
				-    decoded = _decode_mqtt_mapping(raw_data.get("mapping"))
			
 
				-    if decoded:
			
 
				-        return decoded, "mqtt"
			
 
				 
			
 
				-    matched = _match_slots_by_color(filament_usage, raw_data.get("ams"))
			
 
				-    if matched:
			
 
				-        return matched, "color_match"
			
 
				+    # Both of the first two fallbacks read the status payload; the third reads
			
 
				+    # fields ``bambu_mqtt`` maintains on the state object itself, so an empty
			
 
				+    # payload must not short-circuit past it.
			
 
				+    if raw_data:
			
 
				+        decoded = _decode_mqtt_mapping(raw_data.get("mapping"))
			
 
				+        if decoded:
			
 
				+            return decoded, "mqtt"
			
 
				+
			
 
				+        matched = _match_slots_by_color(filament_usage, raw_data.get("ams"))
			
 
				+        if matched:
			
 
				+            return matched, "color_match"
			
 
				+
			
 
				+    single = _single_slot_tray_from_state(state, filament_usage, tray_now_at_start)
			
 
				+    if single is not None:
			
 
				+        slot_id, global_tray_id = single
			
 
				+        # Only the one slot is claimed. The -1 padding is the array's existing
			
 
				+        # "not an AMS tray" value, and the slots carrying it consumed nothing,
			
 
				+        # so no caller resolves them: ``_report_spool_usage_for_slots`` skips
			
 
				+        # zero-gram slots before resolving, ``_print_used_tray_keys`` skips
			
 
				+        # negatives, and report_usage's handled-set skips them too.
			
 
				+        mapping = [-1] * slot_id
			
 
				+        mapping[slot_id - 1] = global_tray_id
			
 
				+        return mapping, "tray_state"
			
 
				 
			
 
				     return None, "none"
			
 
				 
			
@@ -565,6 +664,104 @@ async def _resolve_spool_id_via_slot_assignment(printer_id: int, ams_id: int, tr
 
				         return result.scalar_one_or_none()
			
 
				 
			
 
				 
			
 
				+def _as_positive_number(value) -> float | None:
			
 
				+    """``value`` as a float when it is a usable positive quantity, else None.
			
 
				+
			
 
				+    Rejects bools (``True`` is an int in Python, and ``float(True)`` is 1.0 --
			
 
				+    a weight of 1 g would price a spool per-gram at its whole cost), and
			
 
				+    rejects NaN and infinity, which compare False against every bound and would
			
 
				+    otherwise reach the archive as a NaN cost that no later comparison can
			
 
				+    clear.
			
 
				+    """
			
 
				+    if isinstance(value, bool):
			
 
				+        return None
			
 
				+    try:
			
 
				+        number = float(value)
			
 
				+    except (TypeError, ValueError):
			
 
				+        return None
			
 
				+    if not math.isfinite(number) or number <= 0:
			
 
				+        return None
			
 
				+    return number
			
 
				+
			
 
				+
			
 
				+def _spool_cost_per_gram(spool: dict | None) -> float | None:
			
 
				+    """What one gram off this Spoolman spool costs, or None if it can't be said.
			
 
				+
			
 
				+    Spoolman prices a spool in two places. ``filament.price`` is the catalogue
			
 
				+    figure for a full spool of that filament, and ``price`` on the spool itself
			
 
				+    overrides it when a particular purchase cost something else -- a sale, a
			
 
				+    different vendor, import duty. The spool's own value wins, which is the
			
 
				+    order the Spoolman UI presents them in.
			
 
				+
			
 
				+    The divisor is ``filament.weight``: net filament grams, excluding the core.
			
 
				+    That is the same field the remain-delta path already divides by to turn a
			
 
				+    remain%% drop into grams, so a spool that can be charged by percentage can
			
 
				+    always be priced too.
			
 
				+
			
 
				+    A missing or non-positive price is not a free spool, it is an unpriced one,
			
 
				+    and returns None so the caller can fall back to the global default rate
			
 
				+    rather than silently recording that this print cost nothing. Mirrors the
			
 
				+    ``cost_per_kg > 0`` guard the built-in inventory writer applies to its own
			
 
				+    per-spool rate.
			
 
				+    """
			
 
				+    if not isinstance(spool, dict):
			
 
				+        return None
			
 
				+    filament = spool.get("filament")
			
 
				+    if not isinstance(filament, dict):
			
 
				+        filament = {}
			
 
				+
			
 
				+    # A spool-level 0 is treated as "not overridden" rather than "this roll was
			
 
				+    # free": Spoolman leaves the field null when unset, but an import or an API
			
 
				+    # client that writes 0 instead is common enough that reading it as free
			
 
				+    # would price a whole print at the default rate while a perfectly good
			
 
				+    # catalogue price sat one level down.
			
 
				+    raw_price = spool.get("price")
			
 
				+    if _as_positive_number(raw_price) is None:
			
 
				+        raw_price = filament.get("price")
			
 
				+
			
 
				+    price = _as_positive_number(raw_price)
			
 
				+    weight = _as_positive_number(filament.get("weight"))
			
 
				+    if price is None or weight is None:
			
 
				+        return None
			
 
				+    # Both operands can be finite and the quotient still overflow. A non-finite
			
 
				+    # rate would reach the archive as a NaN or inf cost, and every later
			
 
				+    # comparison against it is False, so nothing downstream would correct it.
			
 
				+    rate = price / weight
			
 
				+    return rate if math.isfinite(rate) else None
			
 
				+
			
 
				+
			
 
				+@dataclass
			
 
				+class _PrintCost:
			
 
				+    """What a print cost, accumulated as each slot is actually charged.
			
 
				+
			
 
				+    Only grams that were both charged to a spool *and* priced from it are
			
 
				+    counted. Everything else -- a slot whose spool has no price, a tray with no
			
 
				+    Spoolman row at all, filament the 3MF never attributed -- is left for the
			
 
				+    caller to cover at the global default rate, in one subtraction against the
			
 
				+    archive's own total. That is the same shape as the built-in inventory
			
 
				+    writer's untracked-grams top-up (#1344), and it means a partially priced
			
 
				+    print reports a whole-print figure rather than only the priced share.
			
 
				+    """
			
 
				+
			
 
				+    cost: float = 0.0
			
 
				+    priced_grams: float = 0.0
			
 
				+    priced: int = 0
			
 
				+    unpriced: int = 0
			
 
				+
			
 
				+    def add(self, grams: float, spool: dict | None, label: str) -> None:
			
 
				+        """Price ``grams`` off ``spool``. Call only after the charge succeeded."""
			
 
				+        if grams <= 0:
			
 
				+            return
			
 
				+        rate = _spool_cost_per_gram(spool)
			
 
				+        if rate is None:
			
 
				+            self.unpriced += 1
			
 
				+            logger.debug("[SPOOLMAN] %s: spool has no usable price, will fall back to the default rate", label)
			
 
				+            return
			
 
				+        self.cost += grams * rate
			
 
				+        self.priced_grams += grams
			
 
				+        self.priced += 1
			
 
				+
			
 
				+
			
 
				 async def _report_spool_usage_for_slots(
			
 
				     client,
			
 
				     filament_usage_items: list[tuple[int, float]],
			
@@ -575,6 +772,7 @@ async def _report_spool_usage_for_slots(
 
				     printer_id: int | None = None,
			
 
				     slot_colors_out: dict[int, str] | None = None,
			
 
				     slot_materials_out: dict[int, str] | None = None,
			
 
				+    cost_out: _PrintCost | None = None,
			
 
				 ) -> int:
			
 
				     """Report usage to Spoolman for a list of (slot_id, grams) pairs.
			
 
				 
			
@@ -621,6 +819,9 @@ async def _report_spool_usage_for_slots(
 
				         # yields an id and is fetched below.
			
 
				         spool_color_hex: str | None = None
			
 
				         spool_material: str | None = None
			
 
				+        # Full spool row, kept so the price fields (#2591) can be read from the
			
 
				+        # same fetch the colour and material already pay for.
			
 
				+        spool_obj: dict | None = None
			
 
				 
			
 
				         spool_tag = _resolve_spool_tag(tray_info, printer_serial, global_tray_id)
			
 
				         if spool_tag:
			
@@ -628,6 +829,7 @@ async def _report_spool_usage_for_slots(
 
				             if spool:
			
 
				                 spool_id_to_use = spool["id"]
			
 
				                 resolution_path = "tag"
			
 
				+                spool_obj = spool
			
 
				                 spool_color_hex = (spool.get("filament") or {}).get("color_hex")
			
 
				                 spool_material = (spool.get("filament") or {}).get("material")
			
 
				 
			
@@ -650,17 +852,19 @@ async def _report_spool_usage_for_slots(
 
				         # id, so fetch the spool once for whichever value is still missing.
			
 
				         # Strictly best-effort: a fetch failure must never abort the weight
			
 
				         # reporting for the remaining slots, so the catch is broad.
			
 
				-        if slot_colors_out is not None or slot_materials_out is not None:
			
 
				+        if slot_colors_out is not None or slot_materials_out is not None or cost_out is not None:
			
 
				             need_color = slot_colors_out is not None and spool_color_hex is None
			
 
				             need_material = slot_materials_out is not None and spool_material is None
			
 
				-            if need_color or need_material:
			
 
				+            need_price = cost_out is not None and spool_obj is None
			
 
				+            if need_color or need_material or need_price:
			
 
				                 try:
			
 
				-                    _fil = (await client.get_spool(spool_id_to_use)).get("filament") or {}
			
 
				+                    spool_obj = await client.get_spool(spool_id_to_use)
			
 
				+                    _fil = spool_obj.get("filament") or {}
			
 
				                     if need_color:
			
 
				                         spool_color_hex = _fil.get("color_hex")
			
 
				                     if need_material:
			
 
				                         spool_material = _fil.get("material")
			
 
				-                except Exception as exc:  # noqa: BLE001 — colour/material are non-critical
			
 
				+                except Exception as exc:  # noqa: BLE001 — colour/material/price are non-critical
			
 
				                     logger.debug("[SPOOLMAN] Slot %s: could not fetch spool filament: %s", slot_id, exc)
			
 
				             if slot_colors_out is not None and spool_color_hex:
			
 
				                 slot_colors_out[slot_id] = spool_color_hex
			
@@ -678,6 +882,10 @@ async def _report_spool_usage_for_slots(
 
				                 resolution_path,
			
 
				             )
			
 
				             spools_updated += 1
			
 
				+            # Priced only after the charge landed, so a spool Spoolman refused
			
 
				+            # cannot contribute to what the print is said to have cost.
			
 
				+            if cost_out is not None:
			
 
				+                cost_out.add(grams_used, spool_obj, f"Slot {slot_id}")
			
 
				         except (SpoolmanNotFoundError, SpoolmanClientError, SpoolmanUnavailableError) as exc:
			
 
				             logger.warning("[SPOOLMAN] Failed to record usage for spool %s: %s", spool_id_to_use, exc)
			
 
				 
			
@@ -698,6 +906,7 @@ async def _report_spool_usage_split_by_tray_changes(
 
				     printer_id: int,
			
 
				     slot_colors_out: dict[int, str] | None = None,
			
 
				     slot_materials_out: dict[int, str] | None = None,
			
 
				+    cost_out: _PrintCost | None = None,
			
 
				 ) -> tuple[int, set[int]]:
			
 
				     """Split each slot's grams across ``tray_changes`` and charge per-segment.
			
 
				 
			
@@ -751,6 +960,7 @@ async def _report_spool_usage_split_by_tray_changes(
 
				             resolution_path = ""
			
 
				             spool_color_hex: str | None = None
			
 
				             spool_material: str | None = None
			
 
				+            spool_obj: dict | None = None
			
 
				 
			
 
				             spool_tag = _resolve_spool_tag(tray_info, printer_serial, tray_global) if tray_info else ""
			
 
				             if spool_tag:
			
@@ -758,6 +968,7 @@ async def _report_spool_usage_split_by_tray_changes(
 
				                 if spool:
			
 
				                     spool_id_to_use = spool["id"]
			
 
				                     resolution_path = "tag"
			
 
				+                    spool_obj = spool
			
 
				                     spool_color_hex = (spool.get("filament") or {}).get("color_hex")
			
 
				                     spool_material = (spool.get("filament") or {}).get("material")
			
 
				 
			
@@ -785,14 +996,19 @@ async def _report_spool_usage_split_by_tray_changes(
 
				             need_material = (
			
 
				                 slot_materials_out is not None and slot_id not in slot_materials_out and spool_material is None
			
 
				             )
			
 
				-            if need_color or need_material:
			
 
				+            # Unlike the colour, every segment needs its own price: each was
			
 
				+            # charged to its own spool, and a backup roll can have cost
			
 
				+            # something different from the one it replaced.
			
 
				+            need_price = cost_out is not None and spool_obj is None
			
 
				+            if need_color or need_material or need_price:
			
 
				                 try:
			
 
				-                    _fil = (await client.get_spool(spool_id_to_use)).get("filament") or {}
			
 
				+                    spool_obj = await client.get_spool(spool_id_to_use)
			
 
				+                    _fil = spool_obj.get("filament") or {}
			
 
				                     if need_color:
			
 
				                         spool_color_hex = _fil.get("color_hex")
			
 
				                     if need_material:
			
 
				                         spool_material = _fil.get("material")
			
 
				-                except Exception as exc:  # noqa: BLE001 — colour/material are non-critical
			
 
				+                except Exception as exc:  # noqa: BLE001 — colour/material/price are non-critical
			
 
				                     logger.debug("[SPOOLMAN] Split slot %s: could not fetch spool filament: %s", slot_id, exc)
			
 
				             if slot_colors_out is not None and slot_id not in slot_colors_out and spool_color_hex:
			
 
				                 slot_colors_out[slot_id] = spool_color_hex
			
@@ -812,6 +1028,8 @@ async def _report_spool_usage_split_by_tray_changes(
 
				                     resolution_path,
			
 
				                 )
			
 
				                 spools_updated += 1
			
 
				+                if cost_out is not None:
			
 
				+                    cost_out.add(round(segment_grams, 2), spool_obj, f"Split slot {slot_id} seg {seg_idx}")
			
 
				             except (SpoolmanNotFoundError, SpoolmanClientError, SpoolmanUnavailableError) as exc:
			
 
				                 logger.warning(
			
 
				                     "[SPOOLMAN] Split slot %s seg %s: failed to record usage for spool %s: %s",
			
@@ -929,7 +1147,11 @@ async def _report_partial_usage(
 
				     # ``_resolve_global_tray_id`` (#2768). An aborted print charges the wrong
			
 
				     # spool just as readily as a finished one.
			
 
				     if not slot_to_tray:
			
 
				-        slot_to_tray, _partial_mapping_source = _resolve_slot_to_tray_fallback(printer_id, filament_usage)
			
 
				+        slot_to_tray, _partial_mapping_source = _resolve_slot_to_tray_fallback(
			
 
				+            printer_id,
			
 
				+            filament_usage,
			
 
				+            getattr(tracking, "tray_now_at_start", None),
			
 
				+        )
			
 
				         logger.info(
			
 
				             "[SPOOLMAN] Partial usage: slot_to_tray=%s (source: %s)",
			
 
				             slot_to_tray,
			
@@ -1124,16 +1346,40 @@ async def report_usage(printer_id: int, archive_id: int):
 
				         # AMS slot directly, so there is nothing to recover for it.
			
 
				         mapping_source = "stored" if slot_to_tray else "none"
			
 
				         if filament_usage and not slot_to_tray:
			
 
				-            slot_to_tray, mapping_source = _resolve_slot_to_tray_fallback(printer_id, filament_usage)
			
 
				+            slot_to_tray, mapping_source = _resolve_slot_to_tray_fallback(printer_id, filament_usage, tray_now_at_start)
			
 
				         logger.info(
			
 
				             "[SPOOLMAN] Archive %s: slot_to_tray=%s (source: %s)",
			
 
				             archive_id,
			
 
				             slot_to_tray,
			
 
				             mapping_source,
			
 
				         )
			
 
				+        # Nothing named a tray for this print and no fallback could recover
			
 
				+        # one, so every slot is about to be resolved by position -- slicer slot
			
 
				+        # 1 to the first loaded tray, and so on. That guess is right for an AMS
			
 
				+        # loaded in slicer order and wrong for any other, and the caller has no
			
 
				+        # way to tell which it got. Say so at a level that survives the default
			
 
				+        # log filter, so a support bundle carries the reason (#2953).
			
 
				+        #
			
 
				+        # Excludes the tray-split path. It never reads ``slot_to_tray`` at all:
			
 
				+        # it charges each segment to the tray the printer announced switching
			
 
				+        # to, which is the same evidence the tray-state fallback is built on and
			
 
				+        # is not a guess. Calling it one would suppress the archive rewrite for
			
 
				+        # exactly the prints -- an AMS-backup runout on a Studio job (#1793 in
			
 
				+        # #2768's conditions) -- whose attribution is best supported.
			
 
				+        mapping_is_guess = bool(filament_usage) and mapping_source == "none" and len(tray_changes) <= 1
			
 
				+        if mapping_is_guess:
			
 
				+            logger.warning(
			
 
				+                "[SPOOLMAN] Archive %s: no slot-to-tray mapping from any source -- "
			
 
				+                "charging by tray position, which is a guess. Verify the spool weights "
			
 
				+                "if the AMS is not loaded in slicer order.",
			
 
				+                archive_id,
			
 
				+            )
			
 
				 
			
 
				         slot_colors: dict[int, str] = {}
			
 
				         slot_materials: dict[int, str] = {}
			
 
				+        # Priced as each charge lands, so the figure the archive ends up with
			
 
				+        # describes the same grams Spoolman actually had deducted (#2591).
			
 
				+        print_cost = _PrintCost()
			
 
				         handled_global_tray_ids: set[int] = set()
			
 
				         spools_updated = 0
			
 
				 
			
@@ -1179,6 +1425,7 @@ async def report_usage(printer_id: int, archive_id: int):
 
				                     printer_id=printer_id,
			
 
				                     slot_colors_out=slot_colors,
			
 
				                     slot_materials_out=slot_materials,
			
 
				+                    cost_out=print_cost,
			
 
				                 )
			
 
				                 spools_updated += split_updated
			
 
				                 handled_global_tray_ids |= split_handled
			
@@ -1195,10 +1442,18 @@ async def report_usage(printer_id: int, archive_id: int):
 
				                     printer_id=printer_id,
			
 
				                     slot_colors_out=slot_colors,
			
 
				                     slot_materials_out=slot_materials,
			
 
				+                    cost_out=print_cost,
			
 
				                 )
			
 
				                 # Track which physical slots the 3MF path already covered so
			
 
				                 # Path 2 doesn't double-charge them.
			
 
				                 for u in filament_usage:
			
 
				+                    if u.get("used_g", 0) <= 0:
			
 
				+                        # ``_report_spool_usage_for_slots`` skipped this slot
			
 
				+                        # before resolving a tray for it, so nothing was
			
 
				+                        # charged and Path 2 is free to cover the slot from
			
 
				+                        # remain% -- claiming it here would suppress a real
			
 
				+                        # drop on the strength of a zero-gram estimate.
			
 
				+                        continue
			
 
				                     slot_id = u.get("slot_id", 0)
			
 
				                     handled_global_tray_ids.add(_resolve_global_tray_id(slot_id, slot_to_tray, ams_trays))
			
 
				 
			
@@ -1220,6 +1475,7 @@ async def report_usage(printer_id: int, archive_id: int):
 
				                 print_used_keys=_print_used_tray_keys(slot_to_tray, tray_now_at_start, current),
			
 
				                 slot_colors_out=slot_colors,
			
 
				                 slot_materials_out=slot_materials,
			
 
				+                cost_out=print_cost,
			
 
				             )
			
 
				             spools_updated += fallback_updates
			
 
				 
			
@@ -1231,11 +1487,33 @@ async def report_usage(printer_id: int, archive_id: int):
 
				         # Stamp the archive's filament colour from the matched Spoolman spools
			
 
				         # so it reflects the curated inventory colour, not the slicer's 3MF
			
 
				         # value (#1494) — mirrors the built-in inventory path in usage_tracker.
			
 
				-        await _apply_spool_colors_to_archive(db, archive_id, filament_usage, slot_colors)
			
 
				+        #
			
 
				+        # Skipped when the mapping was a positional guess. Charging the wrong
			
 
				+        # spool costs grams the owner can put back; rewriting the archive's
			
 
				+        # colour and material on top of it overwrites what the slicer actually
			
 
				+        # recorded, and the print then reads as a different filament than the
			
 
				+        # one that made it, with nothing left to compare against (#2953).
			
 
				+        if mapping_is_guess:
			
 
				+            if slot_colors or slot_materials:
			
 
				+                logger.info(
			
 
				+                    "[SPOOLMAN] Archive %s: leaving filament colour/type as sliced — "
			
 
				+                    "the spools were matched by position, not by a known mapping",
			
 
				+                    archive_id,
			
 
				+                )
			
 
				+        else:
			
 
				+            await _apply_spool_colors_to_archive(db, archive_id, filament_usage, slot_colors)
			
 
				+
			
 
				+            # Same for the material: a slot mapped to a differently-typed spool
			
 
				+            # than it was sliced for otherwise records the sliced type (#2563).
			
 
				+            await _apply_spool_types_to_archive(db, archive_id, filament_usage, slot_materials)
			
 
				 
			
 
				-        # Same for the material: a slot mapped to a differently-typed spool than
			
 
				-        # it was sliced for otherwise records the sliced type (#2563).
			
 
				-        await _apply_spool_types_to_archive(db, archive_id, filament_usage, slot_materials)
			
 
				+        # Cost is applied whether or not the mapping was a guess, unlike the
			
 
				+        # colour and material above. Those overwrite what the slicer recorded,
			
 
				+        # which is why a guess must not touch them; the cost has no such
			
 
				+        # original -- archive.py's figure is itself derived from a default rate
			
 
				+        # -- and the grams have already been deducted from these spools, so the
			
 
				+        # archive should say what that deduction was worth.
			
 
				+        await _apply_spool_cost_to_archive(db, archive_id, print_cost)
			
 
				 
			
 
				 
			
 
				 def _print_used_tray_keys(
			
@@ -1292,6 +1570,7 @@ async def _report_remain_delta_for_slots(
 
				     print_used_keys: set[tuple[int, int]] | None = None,
			
 
				     slot_colors_out: dict[int, str] | None = None,
			
 
				     slot_materials_out: dict[int, str] | None = None,
			
 
				+    cost_out: _PrintCost | None = None,
			
 
				 ) -> int:
			
 
				     """AMS remain%-delta path: write ``(start - current) * filament.weight``
			
 
				     grams to Spoolman for slots the 3MF path didn't cover.
			
@@ -1409,6 +1688,10 @@ async def _report_remain_delta_for_slots(
 
				             continue
			
 
				 
			
 
				         spools_updated += 1
			
 
				+        # ``spool`` here is the full row fetched above for its filament weight,
			
 
				+        # so the price is already in hand (#2591).
			
 
				+        if cost_out is not None:
			
 
				+            cost_out.add(grams_used, spool, f"AMS{ams_id}-T{tray_id}")
			
 
				         # No 3MF slot_id for this path — use the AMS slot key so the maps can
			
 
				         # still be inspected by callers if needed. The archive rewrites
			
 
				         # (#1494 colour, #2563 type) key on 3MF slot_ids, so remain-delta-only
			
@@ -1441,6 +1724,99 @@ async def _report_remain_delta_for_slots(
 
				     return spools_updated
			
 
				 
			
 
				 
			
 
				+async def _apply_spool_cost_to_archive(db, archive_id: int, print_cost: _PrintCost) -> None:
			
 
				+    """Set an archive's cost from what the Spoolman spools that fed it are worth (#2591).
			
 
				+
			
 
				+    Until now this was the one thing the Spoolman integration was asked for by
			
 
				+    name and did not do. ``archive.py`` prices a print once, at archive time,
			
 
				+    from the built-in Filament catalogue matched on the primary type, falling
			
 
				+    back to the global default rate -- and in Spoolman mode nothing ever
			
 
				+    revisited that figure, because the per-spool recompute in
			
 
				+    ``usage_tracker.on_print_complete`` only runs over rows the built-in
			
 
				+    inventory wrote and Spoolman mode writes none. An install with an empty
			
 
				+    catalogue therefore priced every print at the default no matter what the
			
 
				+    linked spool actually cost.
			
 
				+
			
 
				+    Multi-material was wrong twice over there: the primary type's rate applied
			
 
				+    to the *whole* print's grams, so a slot of expensive PA came out at the
			
 
				+    price of the PLA next to it. Summing per charged slot is what fixes that,
			
 
				+    and it falls out of pricing each charge as it is made rather than pricing a
			
 
				+    total afterwards.
			
 
				+
			
 
				+    Grams that could not be priced are covered at the global default rate in a
			
 
				+    single subtraction against the archive's own total -- a slot whose spool has
			
 
				+    no price, a tray with no Spoolman row, and filament the 3MF never attributed
			
 
				+    are all the same case. Without it a print with one priced slot out of four
			
 
				+    would report a quarter of its cost, which is #1344 in a different inventory
			
 
				+    mode.
			
 
				+
			
 
				+    Only on the first run, matching the built-in writer (#1378): reprint actuals
			
 
				+    live in ``PrintLogEntry``, and the archive card keeps the first run's figure
			
 
				+    so a failed 10 g reprint doesn't visually clobber a successful 100 g print.
			
 
				+
			
 
				+    Does nothing when no slot could be priced, leaving whatever ``archive.py``
			
 
				+    recorded. That keeps an install with prices in neither place exactly where
			
 
				+    it was.
			
 
				+    """
			
 
				+    if print_cost.priced == 0:
			
 
				+        if print_cost.unpriced:
			
 
				+            logger.info(
			
 
				+                "[SPOOLMAN] Archive %s: %d charged spool(s) carry no price -- "
			
 
				+                "leaving the cost as recorded at archive time",
			
 
				+                archive_id,
			
 
				+                print_cost.unpriced,
			
 
				+            )
			
 
				+        return
			
 
				+
			
 
				+    from sqlalchemy import func
			
 
				+
			
 
				+    from backend.app.api.routes.settings import get_setting
			
 
				+    from backend.app.models.archive import PrintArchive
			
 
				+    from backend.app.models.print_log import PrintLogEntry
			
 
				+
			
 
				+    archive = (await db.execute(select(PrintArchive).where(PrintArchive.id == archive_id))).scalar_one_or_none()
			
 
				+    if archive is None:
			
 
				+        return
			
 
				+
			
 
				+    total = print_cost.cost
			
 
				+    archive_grams = archive.filament_used_grams or 0
			
 
				+    unpriced_grams = max(0.0, archive_grams - print_cost.priced_grams)
			
 
				+    if unpriced_grams > 0:
			
 
				+        # Malformed settings must not cost the whole usage report; the rate is
			
 
				+        # the least important thing this pass produces.
			
 
				+        try:
			
 
				+            _setting = await get_setting(db, "default_filament_cost")
			
 
				+            default_cost_per_kg = float(_setting) if _setting else 25.0
			
 
				+        except (TypeError, ValueError):
			
 
				+            default_cost_per_kg = 25.0
			
 
				+        if default_cost_per_kg > 0:
			
 
				+            total += (unpriced_grams / 1000.0) * default_cost_per_kg
			
 
				+
			
 
				+    if total <= 0:
			
 
				+        return
			
 
				+
			
 
				+    existing_runs = (
			
 
				+        await db.execute(select(func.count(PrintLogEntry.id)).where(PrintLogEntry.archive_id == archive_id))
			
 
				+    ).scalar()
			
 
				+    if existing_runs:
			
 
				+        return
			
 
				+
			
 
				+    new_cost = round(total, 2)
			
 
				+    if new_cost != archive.cost:
			
 
				+        logger.info(
			
 
				+            "[SPOOLMAN] Archive %s cost %s -> %s (%d slot(s) priced from Spoolman over %.2fg, "
			
 
				+            "%.2fg at the default rate)",
			
 
				+            archive_id,
			
 
				+            archive.cost,
			
 
				+            new_cost,
			
 
				+            print_cost.priced,
			
 
				+            print_cost.priced_grams,
			
 
				+            unpriced_grams,
			
 
				+        )
			
 
				+        archive.cost = new_cost
			
 
				+        await db.commit()
			
 
				+
			
 
				+
			
 
				 async def _apply_spool_colors_to_archive(
			
 
				     db,
			
 
				     archive_id: int,
			
--- a/backend/app/services/stl_thumbnail.py
+++ b/backend/app/services/stl_thumbnail.py
@@ -54,6 +54,28 @@ def _configure_matplotlib_cache() -> None:
 
				 BAMBU_GREEN = "#00AE42"
			
 
				 BACKGROUND_COLOR = "#1a1a1a"
			
 
				 
			
 
				+# Direction of the synthetic light used to shade the mesh. Without a light
			
 
				+# source ``Poly3DCollection`` fills every triangle with the identical colour
			
 
				+# regardless of its normal, so the render comes out a flat silhouette and one
			
 
				+# model is indistinguishable from another (issue #2816).
			
 
				+#
			
 
				+# The azimuth is NOT free. matplotlib's light direction for (az, alt) is
			
 
				+# ``[cos(90-az)cos(alt), sin(90-az)cos(alt), sin(alt)]``, and the camera set by
			
 
				+# ``view_init(elev, azim)`` sits at ``[cos(elev)cos(azim), cos(elev)sin(azim),
			
 
				+# sin(elev)]``. The dot product of the two must be POSITIVE or the light is
			
 
				+# behind the model: at 225 it is -0.34, which lights the two hidden faces and
			
 
				+# gives both visible ones the identical 0.475 — a cube with no contrast down its
			
 
				+# front edge. At 315 it is +0.30, and the two visible sides come out 0.825 and
			
 
				+# 0.475. ``test_light_is_on_the_camera_side`` holds that invariant so the pair
			
 
				+# cannot drift apart again.
			
 
				+LIGHT_AZIMUTH_DEG = 315
			
 
				+LIGHT_ALTITUDE_DEG = 45
			
 
				+
			
 
				+# The camera the light above is chosen against. Named because the two are a PAIR:
			
 
				+# move one without the other and the model goes back to being lit from behind.
			
 
				+VIEW_ELEV_DEG = 25
			
 
				+VIEW_AZIM_DEG = 45
			
 
				+
			
 
				 # Maximum vertices before simplification
			
 
				 MAX_VERTICES = 100000
			
 
				 
			
@@ -66,6 +88,97 @@ MAX_VERTICES = 100000
 
				 MIN_USABLE_STL_BYTES = 200
			
 
				 
			
 
				 
			
 
				+def _repair_winding(mesh, trimesh, label: str) -> None:
			
 
				+    """Make every face wind the same way, and wind it OUTWARD, before shading.
			
 
				+
			
 
				+    matplotlib derives its normals from vertex ORDER, so a triangle wound the
			
 
				+    wrong way shades as though it faced away and the model comes out patchy —
			
 
				+    camouflage rather than a surface. Unshaded this never showed, so lighting the
			
 
				+    render is what makes it matter, and the File Manager takes arbitrary user
			
 
				+    STLs. ``trimesh.load(force="mesh")`` does not repair winding; this does.
			
 
				+
			
 
				+    ``trimesh.repair.fix_winding`` and NOT ``mesh.fix_normals()``: the latter
			
 
				+    reaches ``body_count`` -> ``scipy.csgraph``, and scipy is not a dependency of
			
 
				+    this project. fix_winding goes through networkx, which requirements.txt
			
 
				+    already pins.
			
 
				+
			
 
				+    Three steps, because each one leaves something for the next:
			
 
				+
			
 
				+    * ``fix_winding`` makes the winding agree but is free to settle on either
			
 
				+      orientation, and on a half-inverted sphere it picks INWARD — consistent,
			
 
				+      and consistently lit from inside.
			
 
				+    * ``fix_inversion`` corrects that off the sign of the volume, but only for a
			
 
				+      WATERTIGHT mesh. It returns early otherwise, because a volume measured
			
 
				+      across holes says nothing about which way is out.
			
 
				+    * Which leaves the common case, since a mesh with broken winding is usually
			
 
				+      not watertight either. With no usable volume, decide by whether the faces
			
 
				+      point away from the centroid. Measured on a punctured half-inverted
			
 
				+      icosphere: the first two steps alone left 0 of 1200 faces oriented like the
			
 
				+      correctly wound mesh, a mean render delta of 4.56; with this one it is
			
 
				+      1200 of 1200 and 0.00.
			
 
				+
			
 
				+    The centroid test runs only on a mesh whose winding was already broken, and
			
 
				+    it leaves correct ones alone: closed and punctured spheres, a flat plate, an
			
 
				+    open tube, a non-convex L and two disjoint boxes all sum positive.
			
 
				+
			
 
				+    Gated here rather than at the call sites so the two renderers cannot drift.
			
 
				+    The check is tens of ms where the repair is seconds on a large mesh, so only
			
 
				+    meshes that would otherwise render wrong pay for it.
			
 
				+    """
			
 
				+    import numpy as np
			
 
				+
			
 
				+    if len(mesh.faces) == 0 or mesh.is_winding_consistent:
			
 
				+        return
			
 
				+
			
 
				+    logger.debug("Repairing inconsistent winding before render: %s", label)
			
 
				+    trimesh.repair.fix_winding(mesh)
			
 
				+    trimesh.repair.fix_inversion(mesh)
			
 
				+    if mesh.is_watertight:
			
 
				+        return
			
 
				+
			
 
				+    outward = mesh.triangles.mean(axis=1) - mesh.vertices.mean(axis=0)
			
 
				+    if float(np.einsum("ij,ij->i", mesh.face_normals, outward).sum()) < 0:
			
 
				+        logger.debug("Winding settled inward on a non-watertight mesh, inverting: %s", label)
			
 
				+        mesh.invert()
			
 
				+
			
 
				+
			
 
				+def _shade_kwargs(poly3d, LightSource) -> dict:
			
 
				+    """``shade=True`` and its light, or nothing when the mesh cannot be shaded.
			
 
				+
			
 
				+    matplotlib's ``_shade_colors`` has a fallback for a mesh whose every face
			
 
				+    normal is degenerate, and that fallback returns the colour argument it was
			
 
				+    given, unchanged. Passing a colour STRING — which both renderers do — makes
			
 
				+    it hand back a 0-d ``<U7`` array, and ``to_rgba_array`` then calls ``len()``
			
 
				+    on it and raises ``TypeError: len() of unsized object``.
			
 
				+
			
 
				+    So a file whose facets are all zero-area or collinear rendered fine while the
			
 
				+    output was flat, and would fail outright once lit. That population is real:
			
 
				+    stub and truncated STLs, and hand-written 3MFs with an empty ``<triangles/>``.
			
 
				+    Worse, ``batch_generate_stl_thumbnails`` walks a whole folder with no
			
 
				+    minimum-size pre-skip, so each one would count as a failure in the UI and put
			
 
				+    a traceback in the log — the exact noise ``stl_thumbnail``'s demoted logging
			
 
				+    exists to keep out.
			
 
				+
			
 
				+    Deciding here rather than catching the TypeError keeps the flat render as a
			
 
				+    real outcome instead of an error path, and costs ~6 ms on a 227k-face mesh.
			
 
				+    Identical to matplotlib's own test: a cross product that is finite and
			
 
				+    non-zero for at least one face.
			
 
				+    """
			
 
				+    import numpy as np
			
 
				+
			
 
				+    if len(poly3d) == 0:
			
 
				+        return {}
			
 
				+    tri = np.asarray(poly3d, dtype=float)
			
 
				+    normals = np.cross(tri[:, 0] - tri[:, 1], tri[:, 1] - tri[:, 2])
			
 
				+    lengths = np.linalg.norm(normals, axis=1)
			
 
				+    if not bool(np.any(np.isfinite(lengths) & (lengths > 0))):
			
 
				+        return {}
			
 
				+    return {
			
 
				+        "shade": True,
			
 
				+        "lightsource": LightSource(azdeg=LIGHT_AZIMUTH_DEG, altdeg=LIGHT_ALTITUDE_DEG),
			
 
				+    }
			
 
				+
			
 
				+
			
 
				 def generate_stl_thumbnail(
			
 
				     stl_path: Path,
			
 
				     thumbnails_dir: Path,
			
@@ -98,6 +211,7 @@ def generate_stl_thumbnail(
 
				         # Use Agg backend for headless rendering
			
 
				         matplotlib.use("Agg")
			
 
				         import matplotlib.pyplot as plt
			
 
				+        from matplotlib.colors import LightSource
			
 
				         from mpl_toolkits.mplot3d import Axes3D  # noqa: F401
			
 
				         from mpl_toolkits.mplot3d.art3d import Poly3DCollection
			
 
				 
			
@@ -130,6 +244,14 @@ def generate_stl_thumbnail(
 
				             except Exception as e:
			
 
				                 logger.warning("Mesh simplification failed, using original: %s", e)
			
 
				 
			
 
				+        # Wind every face the same way, and outward, or the shading turns the
			
 
				+        # model into camouflage. See ``_repair_winding``; it must run before the
			
 
				+        # vertices below are read, since a future repair step could move them.
			
 
				+        try:
			
 
				+            _repair_winding(mesh, trimesh, str(stl_path))
			
 
				+        except Exception as e:  # best-effort: a flat render beats no thumbnail
			
 
				+            logger.debug("Winding repair skipped (%s): %s", e, stl_path)
			
 
				+
			
 
				         # Get mesh bounds and center it
			
 
				         vertices = mesh.vertices
			
 
				         bounds_min = vertices.min(axis=0)
			
@@ -153,15 +275,24 @@ def generate_stl_thumbnail(
 
				         ax.set_facecolor(BACKGROUND_COLOR)
			
 
				 
			
 
				         # Create polygon collection from mesh faces
			
 
				+        # Index with the face array rather than building a list of lists. Same
			
 
				+        # data, and Poly3DCollection accepts it directly — but shading walks this
			
 
				+        # structure to generate normals, and on an 82k-face mesh the list form
			
 
				+        # costs ~0.19s against ~0.007s for the ndarray. It speeds up the unshaded
			
 
				+        # path too.
			
 
				         faces = mesh.faces
			
 
				-        poly3d = [[vertices_scaled[vertex] for vertex in face] for face in faces]
			
 
				+        poly3d = vertices_scaled[faces]
			
 
				 
			
 
				+        # ``shade=True`` needs a real ``edgecolors``: matplotlib shades the edge
			
 
				+        # colours alongside the face colours, and an empty array (``"none"``)
			
 
				+        # makes it raise on the broadcast. Keep the two in step if either moves.
			
 
				         collection = Poly3DCollection(
			
 
				             poly3d,
			
 
				             facecolors=BAMBU_GREEN,
			
 
				             edgecolors=BAMBU_GREEN,
			
 
				             linewidths=0.1,
			
 
				             alpha=0.9,
			
 
				+            **_shade_kwargs(poly3d, LightSource),
			
 
				         )
			
 
				         ax.add_collection3d(collection)
			
 
				 
			
@@ -171,7 +302,7 @@ def generate_stl_thumbnail(
 
				         ax.set_zlim(-0.6, 0.6)
			
 
				 
			
 
				         # Set view angle (isometric-ish)
			
 
				-        ax.view_init(elev=25, azim=45)
			
 
				+        ax.view_init(elev=VIEW_ELEV_DEG, azim=VIEW_AZIM_DEG)
			
 
				 
			
 
				         # Remove axes and grid
			
 
				         ax.set_axis_off()
			
--- a/backend/app/services/timelapse_processor.py
+++ b/backend/app/services/timelapse_processor.py
@@ -7,6 +7,7 @@ import tempfile
 
				 from pathlib import Path
			
 
				 
			
 
				 from backend.app.services.camera import get_ffmpeg_path
			
 
				+from backend.app.utils.ffmpeg_output import NO_FFMPEG_OUTPUT, summarize_ffmpeg_stderr
			
 
				 
			
 
				 logger = logging.getLogger(__name__)
			
 
				 
			
@@ -43,8 +44,12 @@ class TimelapseProcessor:
 
				         stdout, stderr = await process.communicate()
			
 
				 
			
 
				         if process.returncode != 0:
			
 
				-            logger.error("ffprobe failed: %s", stderr.decode())
			
 
				-            raise RuntimeError(f"ffprobe failed: {stderr.decode()}")
			
 
				+            # Summarised once and used for both: the raise carried a second,
			
 
				+            # bare ``stderr.decode()`` that could itself raise UnicodeDecodeError
			
 
				+            # on the bytes ffprobe copies out of a broken file (#2968).
			
 
				+            detail = summarize_ffmpeg_stderr(stderr) or NO_FFMPEG_OUTPUT
			
 
				+            logger.error("ffprobe failed: %s", detail)
			
 
				+            raise RuntimeError(f"ffprobe failed: {detail}")
			
 
				 
			
 
				         data = json.loads(stdout.decode())
			
 
				         video_stream = next(
			
@@ -230,7 +235,7 @@ class TimelapseProcessor:
 
				         _, stderr = await process.communicate()
			
 
				 
			
 
				         if process.returncode != 0:
			
 
				-            logger.error("FFmpeg processing failed: %s", stderr.decode())
			
 
				+            logger.error("FFmpeg processing failed: %s", summarize_ffmpeg_stderr(stderr) or NO_FFMPEG_OUTPUT)
			
 
				             return False
			
 
				 
			
 
				         return output_path.exists()
			
--- a/backend/app/services/usage_tracker.py
+++ b/backend/app/services/usage_tracker.py
@@ -10,6 +10,7 @@ AMS remain% delta is the fallback for trays not covered by 3MF data.
 
				 import asyncio
			
 
				 import json
			
 
				 import logging
			
 
				+import re
			
 
				 from dataclasses import dataclass, field
			
 
				 from datetime import datetime, timezone
			
 
				 
			
@@ -738,7 +739,13 @@ async def on_print_complete(
 
				 
			
 
				         search_filename = data.get("filename") or data.get("subtask_name") or (session.print_name if session else "")
			
 
				         if search_filename:
			
 
				-            threemf_path = await _find_3mf_by_filename(printer_id, search_filename, db, app_settings.base_dir)
			
 
				+            threemf_path = await _find_3mf_by_filename(
			
 
				+                printer_id,
			
 
				+                search_filename,
			
 
				+                db,
			
 
				+                app_settings.base_dir,
			
 
				+                print_name=data.get("subtask_name") or (session.print_name if session else None),
			
 
				+            )
			
 
				 
			
 
				     if archive_id or threemf_path:
			
 
				         threemf_results = await _track_from_3mf(
			
@@ -830,6 +837,18 @@ async def on_print_complete(
 
				                     continue  # Already tracked via 3MF
			
 
				 
			
 
				                 if key not in session.tray_remain_start:
			
 
				+                    # No usable remain% when the print began, so there is no delta
			
 
				+                    # to charge. Said out loud for the same reason as the branches
			
 
				+                    # below: a slot the print used, holding a spool the operator
			
 
				+                    # assigned, otherwise vanished from the accounting without a
			
 
				+                    # word. Common on non-RFID spools, which report remain = -1
			
 
				+                    # until a remaining amount is set by hand.
			
 
				+                    if not print_used_keys or key in print_used_keys:
			
 
				+                        logger.info(
			
 
				+                            "[UsageTracker] %s: no valid remain%% at print start, nothing to charge for printer %d",
			
 
				+                            tray_label,
			
 
				+                            printer_id,
			
 
				+                        )
			
 
				                     continue
			
 
				 
			
 
				                 # Skip trays the print never touched. Only enforce when we have
			
@@ -994,32 +1013,165 @@ async def on_print_complete(
 
				     return results
			
 
				 
			
 
				 
			
 
				+# A running print's ``filename`` is the path the printer is executing, and on a
			
 
				+# sliced job that is always ``…/Metadata/plate_<N>.gcode``. Its stem names the
			
 
				+# *plate*, not the model, and every Bambu print in existence has one — so it
			
 
				+# identifies nothing and must never be used to match a 3MF. It reached the
			
 
				+# matcher for real on H2-series and P2S prints, where the file goes to internal
			
 
				+# eMMC, no 3MF can be fetched, and the archive keeps the gcode path as its
			
 
				+# filename: `plate_1` then matched an unrelated `lid_plate_1.gcode.3mf` and that
			
 
				+# print's filament figures were read off a different model entirely.
			
 
				+_GENERIC_PLATE_STEM = re.compile(r"^plate_?\d+$", re.IGNORECASE)
			
 
				+
			
 
				+
			
 
				+def _like_escape(value: str) -> str:
			
 
				+    """Escape LIKE metacharacters so a stem matches literally.
			
 
				+
			
 
				+    ``_`` is a single-character wildcard, and model names are full of them.
			
 
				+    """
			
 
				+    return value.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
			
 
				+
			
 
				+
			
 
				+def _threemf_search_stem(*candidates: str | None) -> str | None:
			
 
				+    """First candidate that names a model, or None if none of them do.
			
 
				+
			
 
				+    Candidates are tried in order and the generic plate name is skipped rather
			
 
				+    than accepted, so a print that only has one falls through to "no match"
			
 
				+    instead of matching everything.
			
 
				+    """
			
 
				+    for raw in candidates:
			
 
				+        if not raw:
			
 
				+            continue
			
 
				+        stem = raw.split("/")[-1].strip()
			
 
				+        for suffix in (".gcode.3mf", ".gcode", ".3mf"):
			
 
				+            if stem.lower().endswith(suffix):
			
 
				+                stem = stem[: -len(suffix)]
			
 
				+                break
			
 
				+        # Stripped only to judge the stem, never to change it: a real archive
			
 
				+        # here is named "…Face Down .gcode.3mf", and a stem trimmed to
			
 
				+        # "…Face Down" no longer matches the file it came from.
			
 
				+        probe = stem.strip()
			
 
				+        if probe and not _GENERIC_PLATE_STEM.match(probe):
			
 
				+            return stem
			
 
				+    return None
			
 
				+
			
 
				+
			
 
				+def _stem_matches(column, stem: str):
			
 
				+    """Filter matching *stem* at a filename boundary rather than anywhere.
			
 
				+
			
 
				+    ``ilike("%<stem>.%")`` also matched a *suffix* of a longer name, which is how
			
 
				+    `plate_1` reached `lid_plate_1.gcode.3mf`. A name is either the whole
			
 
				+    basename or the basename after a directory separator.
			
 
				+    """
			
 
				+    escaped = _like_escape(stem)
			
 
				+    return column.ilike(f"{escaped}.%", escape="\\") | column.ilike(f"%/{escaped}.%", escape="\\")
			
 
				+
			
 
				+
			
 
				+def _expected_plate_for_print(plate_id: int | None, gcode_file: str | None) -> int | None:
			
 
				+    """The plate a running print is on, from whatever was recorded about it.
			
 
				+
			
 
				+    ``plate_id`` is the reliable source, and the archives that need a donor 3MF
			
 
				+    have none: the no-3MF fallback row is created before any 3MF is read, so
			
 
				+    the column is never filled. The gcode path the printer echoed is the other
			
 
				+    source, exact on the firmwares that echo ``Metadata/plate_N.gcode``. Some
			
 
				+    P1S builds echo only the 3MF filename, and then the plate is simply not
			
 
				+    knowable at print start (#2957).
			
 
				+    """
			
 
				+    from backend.app.services.printer_manager import parse_plate_id
			
 
				+
			
 
				+    if plate_id is not None:
			
 
				+        return plate_id
			
 
				+    return parse_plate_id(gcode_file)
			
 
				+
			
 
				+
			
 
				+def _donor_3mf_conflicts(candidate, expected_plate: int | None) -> str | None:
			
 
				+    """Why *candidate* cannot be this print's 3MF, or None if nothing rules it out.
			
 
				+
			
 
				+    A same-name 3MF is not the same print. Bambu Studio writes the printer-side
			
 
				+    filename from the project's ``Title`` metadata, so every plate of a project
			
 
				+    arrives under one name however the user renamed the file on disk, and a
			
 
				+    donor chosen on the name alone hands one plate's slicer estimates to another
			
 
				+    plate's print. A reporter's single-filament job was charged against three
			
 
				+    spools that way, and nothing about the deduction said it was a guess
			
 
				+    (#2957).
			
 
				+
			
 
				+    The plate is the one thing that can settle this. It is the same comparison
			
 
				+    #1204 already makes against a freshly downloaded 3MF, so a single-plate
			
 
				+    export is known to carry its original index rather than a renumbered 1.
			
 
				+
			
 
				+    Filament *count* deliberately is not checked, however tempting: the slicer's
			
 
				+    ``ams_mapping`` is indexed by the project's filament slot -- see
			
 
				+    ``slot_to_tray[slot_id - 1]`` below -- not by the plate's, so a real
			
 
				+    single-filament print reports ``[0, -1, -1, -1]`` and its length says
			
 
				+    nothing about how many filaments the plate uses.
			
 
				+    """
			
 
				+    from backend.app.services.archive import plate_indexes_in_3mf
			
 
				+
			
 
				+    if expected_plate is None:
			
 
				+        return None
			
 
				+
			
 
				+    plates = plate_indexes_in_3mf(candidate)
			
 
				+    if not plates or any(plate is None for plate in plates):
			
 
				+        # Nothing was read, or not all of it was, and neither is evidence about
			
 
				+        # the plate. Refusing here would drop the fallback for every 3MF variant
			
 
				+        # this parser does not understand; downstream reports that honestly as
			
 
				+        # "no filament usage data".
			
 
				+        return None
			
 
				+    if len(plates) == 1 and plates[0] != expected_plate:
			
 
				+        return f"it holds plate {plates[0]}, this print is plate {expected_plate}"
			
 
				+    if expected_plate not in plates:
			
 
				+        # An all-plates export is a good donor precisely when it carries the
			
 
				+        # plate that is running. Without this the plate is looked for
			
 
				+        # downstream, found missing, and the whole file's filaments are summed
			
 
				+        # onto one plate's print.
			
 
				+        return f"it has no plate {expected_plate}"
			
 
				+    return None
			
 
				+
			
 
				+
			
 
				 async def _resolve_3mf_fallback(archive, db: AsyncSession, base_dir):
			
 
				     """Try to find a 3MF file from library or a previous archive when the current archive has none.
			
 
				 
			
 
				     This handles fallback archives (FTP download failed) where the 3MF may already exist
			
 
				     locally from a library upload or a previous successful print of the same file.
			
 
				+
			
 
				+    A name match alone does not make a candidate this print's file, so every
			
 
				+    candidate is put through :func:`_donor_3mf_conflicts` before it is handed
			
 
				+    back (#2957).
			
 
				     """
			
 
				     from pathlib import Path
			
 
				 
			
 
				     from backend.app.models.archive import PrintArchive
			
 
				     from backend.app.models.library import LibraryFile
			
 
				 
			
 
				-    # Derive search name from archive filename (e.g. "benchy.3mf" or "benchy.gcode.3mf")
			
 
				-    search_name = archive.filename or archive.print_name
			
 
				-    if not search_name:
			
 
				-        return None
			
 
				-    # Normalize: strip path parts, get base name
			
 
				-    search_name = search_name.split("/")[-1]
			
 
				-    search_base = search_name.replace(".gcode.3mf", "").replace(".gcode", "").replace(".3mf", "")
			
 
				+    # Derive search name from archive filename (e.g. "benchy.3mf" or "benchy.gcode.3mf"),
			
 
				+    # falling back to the print name when the filename is only a plate path.
			
 
				+    search_base = _threemf_search_stem(archive.filename, archive.print_name)
			
 
				     if not search_base:
			
 
				         return None
			
 
				 
			
 
				+    print_data = (getattr(archive, "extra_data", None) or {}).get("_print_data") or {}
			
 
				+    expected_plate = _expected_plate_for_print(
			
 
				+        getattr(archive, "plate_id", None),
			
 
				+        archive.filename or print_data.get("filename"),
			
 
				+    )
			
 
				+    if expected_plate is None:
			
 
				+        # Worth saying out loud. On the firmwares that echo only the 3MF
			
 
				+        # filename there is nothing to check a donor against, so whatever is
			
 
				+        # accepted below is accepted on its name alone -- which is how the
			
 
				+        # reporter's spools were debited for another plate's filament. The
			
 
				+        # deduction being silent was half the bug (#2957).
			
 
				+        logger.warning(
			
 
				+            "[UsageTracker] 3MF fallback: archive %s does not know its plate (%r), so a same-named "
			
 
				+            "3MF can only be matched on its name",
			
 
				+            archive.id,
			
 
				+            archive.filename,
			
 
				+        )
			
 
				+
			
 
				     # 1. Try library files matching the name (match base name at file boundary)
			
 
				     try:
			
 
				         lib_result = await db.execute(
			
 
				             LibraryFile.active()
			
 
				-            .where(LibraryFile.file_path.ilike(f"%/{search_base}.%") | LibraryFile.file_path.ilike(f"{search_base}.%"))
			
 
				+            .where(_stem_matches(LibraryFile.file_path, search_base))
			
 
				             .where(LibraryFile.file_path.ilike("%.3mf"))
			
 
				             .order_by(LibraryFile.created_at.desc())
			
 
				             .limit(3)
			
@@ -1028,7 +1180,21 @@ async def _resolve_3mf_fallback(archive, db: AsyncSession, base_dir):
 
				             lib_path = Path(lib_file.file_path)
			
 
				             candidate = lib_path if lib_path.is_absolute() else base_dir / lib_file.file_path
			
 
				             if candidate.exists() and candidate.suffix == ".3mf":
			
 
				-                logger.info("[UsageTracker] 3MF fallback: found library file %s for archive %s", candidate, archive.id)
			
 
				+                conflict = _donor_3mf_conflicts(candidate, expected_plate)
			
 
				+                if conflict:
			
 
				+                    logger.warning(
			
 
				+                        "[UsageTracker] 3MF fallback: not using library file %s for archive %s — %s",
			
 
				+                        candidate,
			
 
				+                        archive.id,
			
 
				+                        conflict,
			
 
				+                    )
			
 
				+                    continue
			
 
				+                logger.info(
			
 
				+                    "[UsageTracker] 3MF fallback: found library file %s for archive %s (expected plate=%s)",
			
 
				+                    candidate,
			
 
				+                    archive.id,
			
 
				+                    expected_plate,
			
 
				+                )
			
 
				                 return candidate
			
 
				     except Exception as e:
			
 
				         logger.debug("[UsageTracker] 3MF fallback: library lookup failed: %s", e)
			
@@ -1041,19 +1207,27 @@ async def _resolve_3mf_fallback(archive, db: AsyncSession, base_dir):
 
				             .where(PrintArchive.printer_id == archive.printer_id)
			
 
				             .where(PrintArchive.file_path != "")
			
 
				             .where(PrintArchive.file_path.isnot(None))
			
 
				-            .where(
			
 
				-                PrintArchive.filename.ilike(f"%{search_base}.%") | PrintArchive.filename.ilike(f"{search_base}.%"),
			
 
				-            )
			
 
				+            .where(_stem_matches(PrintArchive.filename, search_base))
			
 
				             .order_by(PrintArchive.created_at.desc())
			
 
				             .limit(3)
			
 
				         )
			
 
				         for prev_archive in prev_result.scalars().all():
			
 
				             candidate = base_dir / prev_archive.file_path
			
 
				             if candidate.exists() and candidate.suffix == ".3mf":
			
 
				+                conflict = _donor_3mf_conflicts(candidate, expected_plate)
			
 
				+                if conflict:
			
 
				+                    logger.warning(
			
 
				+                        "[UsageTracker] 3MF fallback: not using archive %s's file for archive %s — %s",
			
 
				+                        prev_archive.id,
			
 
				+                        archive.id,
			
 
				+                        conflict,
			
 
				+                    )
			
 
				+                    continue
			
 
				                 logger.info(
			
 
				-                    "[UsageTracker] 3MF fallback: found previous archive %s file for archive %s",
			
 
				+                    "[UsageTracker] 3MF fallback: found previous archive %s file for archive %s (expected plate=%s)",
			
 
				                     prev_archive.id,
			
 
				                     archive.id,
			
 
				+                    expected_plate,
			
 
				                 )
			
 
				                 return candidate
			
 
				     except Exception as e:
			
@@ -1067,27 +1241,34 @@ async def _find_3mf_by_filename(
 
				     filename: str,
			
 
				     db: AsyncSession,
			
 
				     base_dir,
			
 
				+    print_name: str | None = None,
			
 
				 ):
			
 
				     """Find a 3MF file by filename from library or previous archives.
			
 
				 
			
 
				     Used when auto-archive is disabled and there's no archive_id, but we still
			
 
				     need the 3MF slicer data for filament usage tracking.
			
 
				+
			
 
				+    ``print_name`` is the model name to fall back to when ``filename`` is the
			
 
				+    printer's plate path, which names no model at all -- and when it is that
			
 
				+    plate path, it is also what keeps a same-named file for a different plate
			
 
				+    from being adopted (#2957); see :func:`_donor_3mf_conflicts`.
			
 
				     """
			
 
				     from pathlib import Path
			
 
				 
			
 
				     from backend.app.models.archive import PrintArchive
			
 
				     from backend.app.models.library import LibraryFile
			
 
				 
			
 
				-    search_name = filename.split("/")[-1] if "/" in filename else filename
			
 
				-    search_base = search_name.replace(".gcode.3mf", "").replace(".gcode", "").replace(".3mf", "")
			
 
				+    search_base = _threemf_search_stem(filename, print_name)
			
 
				     if not search_base:
			
 
				         return None
			
 
				 
			
 
				+    expected_plate = _expected_plate_for_print(None, filename)
			
 
				+
			
 
				     # 1. Try library files matching the name
			
 
				     try:
			
 
				         lib_result = await db.execute(
			
 
				             LibraryFile.active()
			
 
				-            .where(LibraryFile.file_path.ilike(f"%/{search_base}.%") | LibraryFile.file_path.ilike(f"{search_base}.%"))
			
 
				+            .where(_stem_matches(LibraryFile.file_path, search_base))
			
 
				             .where(LibraryFile.file_path.ilike("%.3mf"))
			
 
				             .order_by(LibraryFile.created_at.desc())
			
 
				             .limit(3)
			
@@ -1096,6 +1277,15 @@ async def _find_3mf_by_filename(
 
				             lib_path = Path(lib_file.file_path)
			
 
				             candidate = lib_path if lib_path.is_absolute() else base_dir / lib_file.file_path
			
 
				             if candidate.exists() and candidate.suffix == ".3mf":
			
 
				+                conflict = _donor_3mf_conflicts(candidate, expected_plate)
			
 
				+                if conflict:
			
 
				+                    logger.warning(
			
 
				+                        "[UsageTracker] 3MF (no-archive): not using library file %s for '%s' — %s",
			
 
				+                        candidate,
			
 
				+                        filename,
			
 
				+                        conflict,
			
 
				+                    )
			
 
				+                    continue
			
 
				                 logger.info("[UsageTracker] 3MF (no-archive): found library file %s for '%s'", candidate, filename)
			
 
				                 return candidate
			
 
				     except Exception as e:
			
@@ -1108,15 +1298,22 @@ async def _find_3mf_by_filename(
 
				             .where(PrintArchive.printer_id == printer_id)
			
 
				             .where(PrintArchive.file_path != "")
			
 
				             .where(PrintArchive.file_path.isnot(None))
			
 
				-            .where(
			
 
				-                PrintArchive.filename.ilike(f"%{search_base}.%") | PrintArchive.filename.ilike(f"{search_base}.%"),
			
 
				-            )
			
 
				+            .where(_stem_matches(PrintArchive.filename, search_base))
			
 
				             .order_by(PrintArchive.created_at.desc())
			
 
				             .limit(3)
			
 
				         )
			
 
				         for prev_archive in prev_result.scalars().all():
			
 
				             candidate = base_dir / prev_archive.file_path
			
 
				             if candidate.exists() and candidate.suffix == ".3mf":
			
 
				+                conflict = _donor_3mf_conflicts(candidate, expected_plate)
			
 
				+                if conflict:
			
 
				+                    logger.warning(
			
 
				+                        "[UsageTracker] 3MF (no-archive): not using archive %s's file for '%s' — %s",
			
 
				+                        prev_archive.id,
			
 
				+                        filename,
			
 
				+                        conflict,
			
 
				+                    )
			
 
				+                    continue
			
 
				                 logger.info(
			
 
				                     "[UsageTracker] 3MF (no-archive): found previous archive %s file for '%s'",
			
 
				                     prev_archive.id,
			
@@ -1413,6 +1610,10 @@ async def _track_from_3mf(
 
				                 pass  # Fall back to linear scaling
			
 
				 
			
 
				     results = []
			
 
				+    # Trays this print drew from that no longer have an assignment to charge.
			
 
				+    # Collected rather than acted on inline so one notification covers the whole
			
 
				+    # print instead of one per slot (#2812).
			
 
				+    unassigned_global_trays: list[int] = []
			
 
				 
			
 
				     for usage in filament_usage:
			
 
				         slot_id = usage.get("slot_id", 0)
			
@@ -1639,7 +1840,19 @@ async def _track_from_3mf(
 
				             print_started_at=print_started_at,
			
 
				         )
			
 
				         if spool_id is None:
			
 
				-            logger.info("[UsageTracker] 3MF: no spool assignment at printer %d AMS%d-T%d", printer_id, ams_id, tray_id)
			
 
				+            # WARNING, not INFO: everything upstream of this line succeeded --
			
 
				+            # the 3MF was found, the grams were read, the tray resolved -- and
			
 
				+            # the print will still report success while this filament is never
			
 
				+            # deducted. At INFO it was invisible under the default log level and
			
 
				+            # absent from the reasoning in support bundles (#2812).
			
 
				+            logger.warning(
			
 
				+                "[UsageTracker] 3MF: no spool assignment at printer %d AMS%d-T%d — %.1fg not deducted",
			
 
				+                printer_id,
			
 
				+                ams_id,
			
 
				+                tray_id,
			
 
				+                used_g,
			
 
				+            )
			
 
				+            unassigned_global_trays.append(global_tray_id)
			
 
				             continue
			
 
				 
			
 
				         # Load spool
			
@@ -1749,4 +1962,11 @@ async def _track_from_3mf(
 
				                 )
			
 
				                 archive.filament_type = joined_types
			
 
				 
			
 
				+    if unassigned_global_trays:
			
 
				+        from backend.app.services.spool_assignment_notifications import (
			
 
				+            notify_missing_spool_assignments_on_print_complete,
			
 
				+        )
			
 
				+
			
 
				+        await notify_missing_spool_assignments_on_print_complete(printer_id, unassigned_global_trays, db, logger)
			
 
				+
			
 
				     return results
			
--- a/backend/app/services/virtual_printer/mqtt_bridge.py
+++ b/backend/app/services/virtual_printer/mqtt_bridge.py
@@ -23,9 +23,11 @@ Identity rewriting at cache time:
 
				 
			
 
				   - `upgrade_state.sn` (and any other nested dict's `sn` matching the real
			
 
				     serial) → VP serial
			
 
				-  - `net.info[*].ip` little-endian uint32 → VP bind IP. BambuStudio reads
			
 
				-    this as the FTP destination IP. Without this the slicer FTPs straight
			
 
				-    to the real printer and bypasses Bambuddy.
			
 
				+  - `net.info[*].ip` little-endian uint32 → the address a slicer can reach
			
 
				+    Bambuddy on. BambuStudio reads this as the FTP destination IP. Without
			
 
				+    this the slicer FTPs straight to the real printer and bypasses Bambuddy.
			
 
				+    Normally that address is the VP bind IP; `VIRTUAL_PRINTER_ADVERTISE_ADDRESS`
			
 
				+    overrides it for NAT'd deployments (see `ADVERTISE_ADDRESS_ENV`).
			
 
				   - `ipcam.rtsp_url` is left unchanged: BambuStudio overrides the URL host
			
 
				     with the device IP it bound to (the VP), so the slicer hits the VP's
			
 
				     own RTSPS proxy on port 322.
			
@@ -38,6 +40,7 @@ import copy
 
				 import ipaddress
			
 
				 import json
			
 
				 import logging
			
 
				+import os
			
 
				 import socket
			
 
				 from typing import TYPE_CHECKING
			
 
				 
			
@@ -53,6 +56,24 @@ logger = logging.getLogger(__name__)
 
				 
			
 
				 REFRESH_INTERVAL_SECONDS = 30.0
			
 
				 
			
 
				+# Opt-in override for the address written into `net.info[].ip`. Needed only
			
 
				+# where the address a slicer has to use to reach Bambuddy is not one of the
			
 
				+# container's own interfaces — Docker bridge networking being the case that
			
 
				+# prompted it (#2930), where the bind address is a container-private IP like
			
 
				+# `172.24.0.2` and a slicer that follows it opens an FTP connection to
			
 
				+# nothing. Host and macvlan networking stay the supported modes and need
			
 
				+# nothing set here.
			
 
				+#
			
 
				+# Deliberately an environment variable rather than a change to how the VP IP
			
 
				+# is resolved: the alternative was to prefer the VP's "Network Interface
			
 
				+# Override" (`remote_interface_ip`), which today feeds SSDP and the cert SANs
			
 
				+# only. Reading it here would silently move the FTP destination for every
			
 
				+# install that has it set — the multi-NIC, VLAN and Tailscale setups, i.e.
			
 
				+# exactly the ones most likely to have been tuned by hand. Unset, this
			
 
				+# variable changes nothing. Mirrors `VIRTUAL_PRINTER_PASV_ADDRESS`, which
			
 
				+# exists for the same reason on the FTP side.
			
 
				+ADVERTISE_ADDRESS_ENV = "VIRTUAL_PRINTER_ADVERTISE_ADDRESS"
			
 
				+
			
 
				 # Bambuddy's internal printer state in bambu_mqtt.py (around line 2686+) is
			
 
				 # updated per-field — each `if "X" in data: self.state.X = ...` block leaves
			
 
				 # every other field untouched, so the state accumulates everything the
			
@@ -134,6 +155,32 @@ def _resolve_host_interface_for_target(target_ip: str) -> str | None:
 
				     return ip if isinstance(ip, str) and ip else None
			
 
				 
			
 
				 
			
 
				+def _resolve_advertise_override(vp_name: str) -> str:
			
 
				+    """Return the validated `net.info[].ip` override from the environment, or "".
			
 
				+
			
 
				+    Validated here rather than on each refresh tick for two reasons: a typo
			
 
				+    produces one warning instead of one every 30s, and an unusable value
			
 
				+    falls back to the bind address instead of leaving the rewrite unarmed.
			
 
				+    That second part matters — an unarmed rewrite puts the *real printer IP*
			
 
				+    back in front of the slicer (#1429), so a mistyped override must not be
			
 
				+    able to reopen the leak this whole path exists to close.
			
 
				+    """
			
 
				+    raw = os.environ.get(ADVERTISE_ADDRESS_ENV, "").strip()
			
 
				+    if not raw:
			
 
				+        return ""
			
 
				+    try:
			
 
				+        _ip_to_uint32_le(raw)
			
 
				+    except ValueError:
			
 
				+        logger.warning(
			
 
				+            "[%s] %s=%r is not a dotted-quad IPv4 — ignoring it, using the VP bind address instead",
			
 
				+            vp_name,
			
 
				+            ADVERTISE_ADDRESS_ENV,
			
 
				+            raw,
			
 
				+        )
			
 
				+        return ""
			
 
				+    return raw
			
 
				+
			
 
				+
			
 
				 def _merge_ams_dict(prev_ams: dict, new_ams: dict) -> dict:
			
 
				     """Merge a new ``ams`` blob from an incremental push onto the previous one.
			
 
				 
			
@@ -269,6 +316,10 @@ class MQTTBridge:
 
				         # follow-up: makes silent early-returns visible without grepping the
			
 
				         # source.
			
 
				         self._not_armed_reason: str | None = None
			
 
				+        # NAT escape hatch for `net.info[].ip`, resolved once — the process
			
 
				+        # environment cannot change without a restart. "" means "use the VP
			
 
				+        # bind address", which is every install that has not set it.
			
 
				+        self._advertise_address = _resolve_advertise_override(vp_name)
			
 
				         self._loop: asyncio.AbstractEventLoop | None = None
			
 
				         self._refresh_task: asyncio.Task | None = None
			
 
				         self._stopping = False
			
@@ -427,12 +478,15 @@ class MQTTBridge:
 
				         sees the rewritten value (#1429). Without this sweep the sticky-key
			
 
				         preservation keeps the poisoned `net.info[].ip` alive forever.
			
 
				 
			
 
				-        VP bind IP resolution: when `mqtt_server.bind_address` is empty or
			
 
				-        `0.0.0.0` (the default for VPs that were never assigned a dedicated
			
 
				-        bind IP), fall back to auto-resolving the host interface in the same
			
 
				-        subnet as the printer's IP. Without this fallback, the rewrite never
			
 
				-        arms on a default-config flat-LAN install and `net.info[].ip` leaks
			
 
				-        the real printer IP — slicer follows it on Send (#1429 residual).
			
 
				+        VP IP resolution, in order: the `VIRTUAL_PRINTER_ADVERTISE_ADDRESS`
			
 
				+        override if one is set (NAT'd deployments where no local interface
			
 
				+        carries the address slicers use — see `ADVERTISE_ADDRESS_ENV`), then
			
 
				+        `mqtt_server.bind_address`, then — when that is empty or `0.0.0.0`,
			
 
				+        the default for VPs never assigned a dedicated bind IP — the host
			
 
				+        interface sharing a subnet with the printer's IP. Without that last
			
 
				+        fallback the rewrite never arms on a default-config flat-LAN install
			
 
				+        and `net.info[].ip` leaks the real printer IP — the slicer follows it
			
 
				+        on Send (#1429 residual).
			
 
				         """
			
 
				 
			
 
				         def _log_not_armed(reason: str) -> None:
			
@@ -463,14 +517,19 @@ class MQTTBridge:
 
				             )
			
 
				             return
			
 
				 
			
 
				-        vp_ip = getattr(self._mqtt_server, "bind_address", None)
			
 
				-        vp_ip_source = "bind_address"
			
 
				+        if self._advertise_address:
			
 
				+            vp_ip = self._advertise_address
			
 
				+            vp_ip_source = ADVERTISE_ADDRESS_ENV
			
 
				+        else:
			
 
				+            vp_ip = getattr(self._mqtt_server, "bind_address", None)
			
 
				+            vp_ip_source = "bind_address"
			
 
				         if not vp_ip or vp_ip in ("0.0.0.0", ""):  # nosec B104
			
 
				             resolved = _resolve_host_interface_for_target(target_ip)
			
 
				             if not resolved:
			
 
				                 _log_not_armed(
			
 
				                     f"no host interface shares a subnet with printer IP {target_ip} "
			
 
				-                    "(and VP bind_address is 0.0.0.0/empty)"
			
 
				+                    f"(and VP bind_address is 0.0.0.0/empty) — set {ADVERTISE_ADDRESS_ENV} "
			
 
				+                    "to the address slicers reach Bambuddy on if this host is NAT'd"
			
 
				                 )
			
 
				                 return
			
 
				             vp_ip = resolved
			
@@ -514,7 +573,7 @@ class MQTTBridge:
 
				                 )
			
 
				 
			
 
				     def _rewrite_net_info_ips(self, print_state: dict) -> int:
			
 
				-        """Rewrite every non-zero `net.info[].ip` in `print_state` to the VP bind IP.
			
 
				+        """Rewrite every non-zero `net.info[].ip` in `print_state` to the VP's IP.
			
 
				 
			
 
				         Returns the number of entries rewritten. Mutates `print_state` in place.
			
 
				 
			
@@ -595,7 +654,7 @@ class MQTTBridge:
 
				             # stream directly from the printer. On the same LAN this works as
			
 
				             # long as the slicer's stored access code matches the printer's
			
 
				             # (i.e. configure the VP with the same access code as its target).
			
 
				-            # Rewrite real printer IP → VP bind IP in `net.info[*].ip` so the
			
 
				+            # Rewrite real printer IP → the VP's IP in `net.info[*].ip` so the
			
 
				             # slicer's FTP destination resolves to the VP, not the real printer.
			
 
				             self._rewrite_net_info_ips(print_data)
			
 
				             # Defensive deep copy on store so the cache is fully decoupled from
			
--- a/backend/app/utils/ams_drying.py
+++ b/backend/app/utils/ams_drying.py
@@ -0,0 +1,88 @@
 
				+"""Shared reading of the firmware's own AMS drying state.
			
 
				+
			
 
				+Kept as a leaf module on purpose. ``drying_preflight`` would be the natural
			
 
				+home, but it imports ``printer_manager``, which imports ``bambu_mqtt`` — and
			
 
				+``bambu_mqtt`` is one of the callers here, so putting these there would close an
			
 
				+import cycle. Nothing in this module imports from the app.
			
 
				+"""
			
 
				+
			
 
				+from collections.abc import Mapping
			
 
				+from datetime import datetime, timedelta
			
 
				+from typing import Any
			
 
				+
			
 
				+# ``dry_status`` is bits 4-7 of the per-AMS ``info`` hex string (BambuStudio
			
 
				+# DevFilaSystem.cpp): 0=Off, 1=Checking, 2=Drying, 3=Cooling, 4=Stopping,
			
 
				+# 5=Error, 6=HeatOutOfControl, 7=PrdTesting. Only the first three mean a cycle
			
 
				+# is still live.
			
 
				+#
			
 
				+# 4 (Stopping) and 5 (Error) are excluded because the cycle is over or ending.
			
 
				+# 6 (HeatOutOfControl) is excluded deliberately and for a different reason: an
			
 
				+# AMS that has lost thermal control is exactly when a high-temperature alarm
			
 
				+# should still reach the user, so it must never read as "expected heat".
			
 
				+ACTIVE_DRY_STATUSES = frozenset({1, 2, 3})  # Checking, Drying, Cooling
			
 
				+
			
 
				+
			
 
				+def is_drying_active(ams_data: Any) -> bool:
			
 
				+    """True when this AMS unit reports a drying cycle in progress.
			
 
				+
			
 
				+    Two independent signals, because neither alone is sufficient. ``dry_time``
			
 
				+    is minutes remaining and reads 0 through the cooling phase that closes a
			
 
				+    cycle; ``dry_status`` covers that phase but is only present when the
			
 
				+    firmware sent a parseable ``info`` field.
			
 
				+    """
			
 
				+    if not isinstance(ams_data, Mapping):
			
 
				+        return False
			
 
				+    try:
			
 
				+        if int(ams_data.get("dry_time") or 0) > 0:
			
 
				+            return True
			
 
				+    except (TypeError, ValueError):
			
 
				+        pass  # Unparseable countdown — fall through to the phase field
			
 
				+    try:
			
 
				+        return int(ams_data["dry_status"]) in ACTIVE_DRY_STATUSES
			
 
				+    except (KeyError, TypeError, ValueError):
			
 
				+        return False
			
 
				+
			
 
				+
			
 
				+def temperature_alarm_suppressed(
			
 
				+    *,
			
 
				+    drying_active: bool,
			
 
				+    temperature: float | None,
			
 
				+    threshold: float,
			
 
				+    latched_at: datetime | None,
			
 
				+    now: datetime,
			
 
				+    grace_minutes: int,
			
 
				+) -> tuple[bool, datetime | None]:
			
 
				+    """Decide whether to hold back the AMS high-temperature alarm (#1802).
			
 
				+
			
 
				+    Drying heats an AMS far past the alarm threshold by design — 45 C for PLA,
			
 
				+    65 C for PETG, up to 85 C on an AMS-HT, against a default threshold of
			
 
				+    35 C — so without this the alarm fires once an hour for the length of the
			
 
				+    cycle and keeps going while the unit cools back down.
			
 
				+
			
 
				+    Returns ``(suppress, latched_at)``. The second element is the latch to
			
 
				+    persist: a timestamp while suppression is in force, ``None`` to clear it.
			
 
				+
			
 
				+    Suppression is released as soon as the unit reads back at or below the
			
 
				+    threshold rather than after a fixed delay, so a 65 C cycle in a cold
			
 
				+    basement and a 45 C one in a warm room each get exactly the cool-down they
			
 
				+    need. ``grace_minutes`` only bounds the case where the unit never returns
			
 
				+    below the threshold at all — and a unit that stays that hot would have been
			
 
				+    alarming with no drying involved, so releasing there restores the ordinary
			
 
				+    behaviour instead of inventing a new alert.
			
 
				+    """
			
 
				+    if drying_active:
			
 
				+        return True, now
			
 
				+    if latched_at is None:
			
 
				+        return False, None
			
 
				+    # Back at a normal storage temperature: the cool-down is over. Note this is
			
 
				+    # also the only path that can clear the latch promptly, so it is checked
			
 
				+    # before the cap.
			
 
				+    if temperature is not None and temperature <= threshold:
			
 
				+        return False, None
			
 
				+    # ``latched_at`` is never in the future: the caller either just stamped it
			
 
				+    # with this ``now`` or read it back through a loader that clamps. A future
			
 
				+    # stamp would make this difference negative and hold suppression for the
			
 
				+    # skew on top of the cap, which is why the clamp lives at the read.
			
 
				+    if now - latched_at >= timedelta(minutes=grace_minutes):
			
 
				+        return False, None
			
 
				+    return True, latched_at
			
--- a/backend/app/utils/archive_paths.py
+++ b/backend/app/utils/archive_paths.py
@@ -58,6 +58,24 @@ def _legacy_shared_photos_dir(archive: object) -> Path | None:
 
				     return settings.base_dir / "photos"  # SEC-PATH-OK: constant subdirectory
			
 
				 
			
 
				 
			
 
				+def _pre_recovery_photos_dir(archive: object) -> Path | None:
			
 
				+    """Where this archive's photos were written while it had no 3MF.
			
 
				+
			
 
				+    An archive that started as a no-3MF fallback and was later filled in from a
			
 
				+    3MF that turned up (#2957) changes directory: ``archive_dir`` derives from
			
 
				+    ``file_path``, which goes from empty to a real path. Anything written to
			
 
				+    ``<archive_dir>/<id>/photos`` before that moment is still there, so it stays
			
 
				+    a lookup candidate afterwards -- the same reason
			
 
				+    :func:`_legacy_shared_photos_dir` exists.
			
 
				+
			
 
				+    None while ``file_path`` is empty, where this *is* the current directory and
			
 
				+    the caller already checks it.
			
 
				+    """
			
 
				+    if not (getattr(archive, "file_path", "") or ""):
			
 
				+        return None
			
 
				+    return settings.archive_dir / str(archive.id) / "photos"  # SEC-PATH-OK: archive.id is an int primary key
			
 
				+
			
 
				+
			
 
				 def find_archive_photo(archive: object, filename: str) -> Path | None:
			
 
				     """Locate an existing photo, or None if it is in neither location.
			
 
				 
			
@@ -67,7 +85,11 @@ def find_archive_photo(archive: object, filename: str) -> Path | None:
 
				     one caller is a background notification task, where an HTTP error would
			
 
				     have nowhere to go.
			
 
				     """
			
 
				-    for directory in (archive_photos_dir(archive), _legacy_shared_photos_dir(archive)):
			
 
				+    for directory in (
			
 
				+        archive_photos_dir(archive),
			
 
				+        _legacy_shared_photos_dir(archive),
			
 
				+        _pre_recovery_photos_dir(archive),
			
 
				+    ):
			
 
				         if directory is None:
			
 
				             continue
			
 
				         try:
			
--- a/backend/app/utils/color_utils.py
+++ b/backend/app/utils/color_utils.py
@@ -2,6 +2,60 @@
 
				 
			
 
				 import math
			
 
				 
			
 
				+# Alpha byte that means "fully opaque". Bambu's firmware reports every opaque
			
 
				+# spool as RRGGBBFF, so this is the overwhelmingly common value.
			
 
				+_OPAQUE_ALPHA = "FF"
			
 
				+
			
 
				+
			
 
				+def spoolman_color_hex(rgba: str | None) -> str | None:
			
 
				+    """Normalise an RRGGBB(AA) value to what Spoolman's ``color_hex`` should hold.
			
 
				+
			
 
				+    Eight characters only when the spool is genuinely translucent. Bambuddy used
			
 
				+    to truncate to six unconditionally, which turned a clear spool's ``00000000``
			
 
				+    into opaque black (#2912); passing everything through instead would rewrite
			
 
				+    the ``color_hex`` of every opaque spool on its next touch, churning records in
			
 
				+    people's Spoolman for no benefit. Keeping the opaque case at six characters
			
 
				+    leaves existing data byte-identical.
			
 
				+
			
 
				+    Returns ``None`` for a missing value. A value shorter than six characters is
			
 
				+    passed through unchanged so a malformed colour is not reshaped into something
			
 
				+    that looks valid; a value between six and eight is truncated to six, which is
			
 
				+    what the pre-#2912 behaviour did and what the six-character path still means.
			
 
				+    Neither is reachable through ``_validate_rgba``, which admits only 6 or 8.
			
 
				+    """
			
 
				+    if not rgba:
			
 
				+        return None
			
 
				+    clean = rgba.strip().removeprefix("#").upper()
			
 
				+    if len(clean) < 6:
			
 
				+        return clean or None
			
 
				+    if len(clean) >= 8 and clean[6:8] != _OPAQUE_ALPHA:
			
 
				+        return clean[:8]
			
 
				+    return clean[:6]
			
 
				+
			
 
				+
			
 
				+def color_match_key(color_hex: str | None) -> str:
			
 
				+    """Return the key two colours are compared on: **the shape they would be stored as**.
			
 
				+
			
 
				+    Deliberately the same rule as :func:`spoolman_color_hex`, so two colours match
			
 
				+    exactly when storing them would produce the same value. That settles both
			
 
				+    directions of the alpha question at once (#2912):
			
 
				+
			
 
				+    ==============  ============  ==================================================
			
 
				+    value           key           consequence
			
 
				+    ==============  ============  ==================================================
			
 
				+    ``000000``      ``000000``    existing six-character data
			
 
				+    ``000000FF``    ``000000``    still matches it — the upgrade guard, without which
			
 
				+                                  the next AMS sync mints a duplicate filament for
			
 
				+                                  every spool on the instance
			
 
				+    ``00000000``    ``00000000``  a clear spool gets its own filament and is never
			
 
				+                                  conflated with the black one, in either direction
			
 
				+    ==============  ============  ==================================================
			
 
				+
			
 
				+    Returns ``""`` rather than ``None`` for a missing value so callers can compare
			
 
				+    without guarding, which is the only reason this is not simply an alias.
			
 
				+    """
			
 
				+    return spoolman_color_hex(color_hex) or ""
			
 
				+
			
 
				 
			
 
				 def colors_similar(hex_a: str, hex_b: str, threshold: int = 50) -> bool:
			
 
				     """Compare two RRGGBB(AA) hex colors with tolerance for RFID/firmware variations.
			
--- a/backend/app/utils/ffmpeg_output.py
+++ b/backend/app/utils/ffmpeg_output.py
@@ -0,0 +1,102 @@
 
				+"""Turning an ffmpeg subprocess's stderr into a log line worth reading (#2968).
			
 
				+
			
 
				+ffmpeg opens every run with ~20 lines of version, build and library banner and
			
 
				+prints its diagnosis *last*. Truncating that from the front -- ``stderr[:200]``,
			
 
				+which is what most call sites did -- keeps the banner and throws the diagnosis
			
 
				+away. A reporter's H2D produced twelve of these, and every one of them read
			
 
				+
			
 
				+    ffmpeg frame bytes capture failed (code 183): ffmpeg version 7.1.4-0+deb13u1
			
 
				+    Copyright (c) 2000-2026 the FFmpeg developers  built with gcc 14 (Debian
			
 
				+    14.2.0-19)  configuration: --prefix=/usr --extra-version=0+deb13u1 --toolch
			
 
				+
			
 
				+-- 200 characters that are identical on every install and say nothing about why
			
 
				+the capture failed. The exit code was the only usable byte in the whole line.
			
 
				+
			
 
				+The banner-stripping summariser this module holds was written for #925 and
			
 
				+lived as a private helper in ``api/routes/camera.py``, where the streaming
			
 
				+endpoint used it. Ten other places log ffmpeg or ffprobe stderr -- snapshot
			
 
				+capture, last-frame extraction, the layer-timelapse stitch, the archive's MP4
			
 
				+conversion, external USB and RTSP capture and streaming, and timelapse
			
 
				+post-processing. Seven of them truncated from the front, two logged the whole
			
 
				+banner, and one already kept the tail. They all come here now, so they cannot
			
 
				+drift again.
			
 
				+
			
 
				+Redaction is part of the summary rather than each caller's job. ffmpeg echoes
			
 
				+its input URL back in the ``Input #0`` line, so a camera password or a printer
			
 
				+access code reaches stderr on any failure; seven of those ten logged it
			
 
				+unmasked. A helper that redacts is one that cannot be called wrong.
			
 
				+
			
 
				+Kept as a leaf module -- stdlib plus :mod:`core.logging_filters`, which is
			
 
				+itself stdlib-only -- so the services and the route can all reach it without
			
 
				+pulling a startup graph behind them.
			
 
				+"""
			
 
				+
			
 
				+from __future__ import annotations
			
 
				+
			
 
				+from backend.app.core.logging_filters import redact_url_credentials
			
 
				+
			
 
				+# What ffmpeg prints before it has anything to say. Every line of the banner is
			
 
				+# either the version line or an indented continuation, and a real diagnostic is
			
 
				+# never indented this way, so the match is on the exact prefixes rather than on
			
 
				+# indentation alone -- ``  Duration: ...`` and ``    Stream #0:0 ...`` are
			
 
				+# indented too and are worth keeping.
			
 
				+_BANNER_PREFIXES = (
			
 
				+    "ffmpeg version ",
			
 
				+    "ffprobe version ",
			
 
				+    "  built with ",
			
 
				+    "  configuration:",
			
 
				+    "  libavutil ",
			
 
				+    "  libavcodec ",
			
 
				+    "  libavformat ",
			
 
				+    "  libavdevice ",
			
 
				+    "  libavfilter ",
			
 
				+    "  libswscale ",
			
 
				+    "  libswresample ",
			
 
				+    "  libpostproc ",
			
 
				+)
			
 
				+
			
 
				+# How much of the tail to keep. ffmpeg's diagnosis is the last thing it writes,
			
 
				+# and ten lines is enough to carry the error plus the input analysis that
			
 
				+# explains it without letting a chatty decoder rotate the log file.
			
 
				+_MAX_LINES = 10
			
 
				+
			
 
				+# And a ceiling on the whole thing. Ten lines is only a bound on the log record
			
 
				+# if the lines are a sane length, and ffmpeg quotes what the peer sent it back
			
 
				+# at us -- a printer's RTSP response is not something Bambuddy controls. Well
			
 
				+# above any real diagnosis, so this only ever trims a line that was already not
			
 
				+# going to be read.
			
 
				+_MAX_CHARACTERS = 2000
			
 
				+
			
 
				+# What to log when the summary is empty. A failure whose stderr held nothing but
			
 
				+# the banner still deserves a line saying so -- ``failed: `` with an empty tail
			
 
				+# reads like a truncation bug rather than a printer that closed the connection.
			
 
				+NO_FFMPEG_OUTPUT = "no diagnostic output"
			
 
				+
			
 
				+
			
 
				+def summarize_ffmpeg_stderr(text: str | bytes | None) -> str:
			
 
				+    """Strip ffmpeg's boilerplate banner and keep the last lines that matter.
			
 
				+
			
 
				+    Accepts raw ``bytes`` as well as ``str`` and decodes with ``errors=
			
 
				+    "replace"``: ffmpeg copies fragments of the stream into its error messages,
			
 
				+    so a bare ``.decode()`` at the call site can raise ``UnicodeDecodeError``
			
 
				+    while reporting an unrelated failure. Losing the diagnosis to a second
			
 
				+    exception is the one outcome worse than logging the banner.
			
 
				+
			
 
				+    Returns ``""`` when there is nothing left after the banner, which is the
			
 
				+    signal the streaming endpoint uses to stay quiet. One-shot callers that log
			
 
				+    unconditionally should fall back to :data:`NO_FFMPEG_OUTPUT`.
			
 
				+    """
			
 
				+    if not text:
			
 
				+        return ""
			
 
				+    if isinstance(text, (bytes, bytearray)):
			
 
				+        text = text.decode(errors="replace")
			
 
				+    # Redaction runs on the whole string before anything is dropped: a
			
 
				+    # credentialed URL that straddles the cut would otherwise leave its tail in
			
 
				+    # the log with no ``@`` left for the pattern to anchor on.
			
 
				+    text = redact_url_credentials(text) or ""
			
 
				+    meaningful = [line for line in text.splitlines() if line.strip() and not line.startswith(_BANNER_PREFIXES)]
			
 
				+    summary = "\n".join(meaningful[-_MAX_LINES:])
			
 
				+    if len(summary) > _MAX_CHARACTERS:
			
 
				+        # From the end, for the same reason the whole module exists.
			
 
				+        summary = "..." + summary[-_MAX_CHARACTERS:]
			
 
				+    return summary
			
--- a/backend/app/utils/filament_types.py
+++ b/backend/app/utils/filament_types.py
@@ -15,8 +15,18 @@ which reduces a tray type to a drying-preset key. "Which drying profile?" is a
 
				 genuinely different question with a different answer — PLA Silk dries like PLA
			
 
				 but does not print like it — so folding those together would be the wrong kind
			
 
				 of tidy.
			
 
				+
			
 
				+Two more readings of a filament type live here for the same reason. Writing one
			
 
				+into an AMS slot needs the name the printer knows rather than the one on the
			
 
				+spool (``printer_filament_type``), and two guards need to agree on when a value
			
 
				+is a material name rather than a preset the printer can resolve
			
 
				+(``is_material_name``). Both were open-coded and inconsistent before #2902.
			
 
				 """
			
 
				 
			
 
				+import re
			
 
				+
			
 
				+from backend.app.utils.filament_ids import GENERIC_FILAMENT_IDS, MATERIAL_TEMPS
			
 
				+
			
 
				 # Types within a group are interchangeable on the printer side; Bambu Lab
			
 
				 # firmware treats them as the same material. The first entry is canonical.
			
 
				 #
			
@@ -60,3 +70,230 @@ def canonical_filament_type(ftype: str | None) -> str:
 
				 def filament_types_compatible(a: str | None, b: str | None) -> bool:
			
 
				     """Whether two filament types may stand in for one another."""
			
 
				     return canonical_filament_type(a) == canonical_filament_type(b)
			
 
				+
			
 
				+
			
 
				+# ---------------------------------------------------------------------------
			
 
				+# Printer-side material names
			
 
				+# ---------------------------------------------------------------------------
			
 
				+
			
 
				+# What a Bambu printer and the slicers accept in an AMS slot's ``tray_type``.
			
 
				+# Grounded in the catalogues this repo already carries: ``filament_fields.json``
			
 
				+# is the list Bambuddy itself offers when a preset is created, so every value in
			
 
				+# it has to appear here -- ``TestTheMaterialsBambuddyOffers`` fails if one does
			
 
				+# not. On top of that, every "Generic X" entry in
			
 
				+# ``cloud._BUILTIN_FILAMENT_NAMES`` names a real type, the "Bambu X" entries add
			
 
				+# the composites, and the frontend's ``parsePresetName`` list contributes
			
 
				+# PEEK / PEI / PC-CF / PC-ABS.
			
 
				+#
			
 
				+# A filled or foamed variant is a type of its own, not a flavour of the base
			
 
				+# material: PLA-AERO is a foaming PLA and PLA-GF a glass-filled one, and a slot
			
 
				+# that reduces either to "PLA" invites a plain PLA plate onto filament that
			
 
				+# will not print it. Four of the ones the dropdown offers were missing when
			
 
				+# #2902 first landed and were being reduced exactly that way, ASA-AERO -- which
			
 
				+# only the cloud catalogue names (GFB02) -- with them. See the issue thread,
			
 
				+# where @doncaruana caught PLA Aero.
			
 
				+#
			
 
				+# Product lines, by contrast, are deliberately absent. "PLA Matte", "PETG HF"
			
 
				+# and "eSUN PLA+" are things you buy, not types the firmware knows -- they
			
 
				+# belong in ``tray_sub_brands``, which is where Bambu itself puts them.
			
 
				+_PRINTER_TYPES: tuple[str, ...] = (
			
 
				+    # Order within a length matters for ties: "PLA/PHA" must read as PLA.
			
 
				+    "PLA-AERO",
			
 
				+    "ASA-AERO",
			
 
				+    "PAHT-CF",
			
 
				+    "PA12-CF",
			
 
				+    "PETG-CF",
			
 
				+    "PPS-CF",
			
 
				+    "PPS-GF",
			
 
				+    "PPA-CF",
			
 
				+    "PPA-GF",
			
 
				+    "PLA-CF",
			
 
				+    "PLA-GF",
			
 
				+    "PA6-CF",
			
 
				+    "PA6-GF",
			
 
				+    "ABS-GF",
			
 
				+    "ASA-CF",
			
 
				+    "ASA-GF",
			
 
				+    "PET-CF",
			
 
				+    "PC-ABS",
			
 
				+    "PA-CF",
			
 
				+    "PC-CF",
			
 
				+    "PP-CF",
			
 
				+    "PP-GF",
			
 
				+    "PE-CF",
			
 
				+    "PCTG",
			
 
				+    "PETG",
			
 
				+    "BVOH",
			
 
				+    "HIPS",
			
 
				+    "PEEK",
			
 
				+    "PLA",
			
 
				+    "PHA",
			
 
				+    "ABS",
			
 
				+    "ASA",
			
 
				+    "TPU",
			
 
				+    "PVA",
			
 
				+    "PPS",
			
 
				+    "EVA",
			
 
				+    "PEI",
			
 
				+    "PC",
			
 
				+    "PA",
			
 
				+    "PP",
			
 
				+    "PE",
			
 
				+)
			
 
				+
			
 
				+# Names that are a material by another name. ``GENERIC_FILAMENT_IDS`` already
			
 
				+# points NYLON and PA at the same generic id, so they are the same thing to
			
 
				+# everything downstream of here.
			
 
				+_TYPE_ALIASES: dict[str, str] = {
			
 
				+    "NYLON": "PA",
			
 
				+}
			
 
				+
			
 
				+_PRINTER_TYPE_SET = frozenset(_PRINTER_TYPES)
			
 
				+
			
 
				+# Longest first, so "PLA-CF" is recognised before the "PLA" inside it. Sorted
			
 
				+# stably, so the declaration order above still decides same-length ties.
			
 
				+_TYPES_LONGEST_FIRST: tuple[str, ...] = tuple(sorted((*_PRINTER_TYPES, *_TYPE_ALIASES), key=len, reverse=True))
			
 
				+
			
 
				+# Splits a material name into words while keeping "-" and "+" inside them:
			
 
				+# "PLA-CF" is one word, "PLA/PHA" is two, and the "+" of "PLA+" stays attached
			
 
				+# so the prefix rule below can see a non-letter after the type.
			
 
				+_WORDS = re.compile(r"[^A-Z0-9+\-]+")
			
 
				+
			
 
				+
			
 
				+def _word_names_type(word: str, candidate: str) -> bool:
			
 
				+    """Whether one word of a material name says "this is a ``candidate``"."""
			
 
				+    if word == candidate:
			
 
				+        return True
			
 
				+    # Two-letter types are too short to recognise inside a longer word. "PA" is
			
 
				+    # nylon and "Pastel" is not, and there is no reading of the rules below that
			
 
				+    # separates them -- so PA, PC, PE and PP are taken only as a word of their
			
 
				+    # own. A spool whose material really is bare nylon still says so.
			
 
				+    if len(candidate) < 3:
			
 
				+        return False
			
 
				+    # A prefix counts only when a non-letter follows it -- "PLA+" and "PETG-HS"
			
 
				+    # are the type, "PLASTIC" is a word that merely starts like one.
			
 
				+    if word.startswith(candidate) and not word[len(candidate)].isalpha():
			
 
				+        return True
			
 
				+    # A suffix needs no such guard: "HTPLA" and "rPETG" are how vendors write
			
 
				+    # their own PLA and PETG, and nothing else ends in a material name.
			
 
				+    return word.endswith(candidate)
			
 
				+
			
 
				+
			
 
				+def printer_filament_type(material: str | None) -> str:
			
 
				+    """Reduce a spool's material to the name an AMS slot can carry.
			
 
				+
			
 
				+    Bambuddy lets a spool's material be anything -- typed by hand, synced from
			
 
				+    Spoolman, or picked from the colour catalogue, whose material column is the
			
 
				+    vendor's product line ("PLA+", "HTPLA", "PolyTerra PLA"). Every assignment
			
 
				+    path then wrote that string into the slot's ``tray_type``, and a slot whose
			
 
				+    type is "PLA+" satisfies nothing that asks for PLA: not the slicer, and not
			
 
				+    Bambuddy's own dispatch matcher, which compares the printer's reported
			
 
				+    ``tray_type`` to the 3MF's declared type as plain equality (issue #2902).
			
 
				+
			
 
				+    Returns the material name unchanged when it cannot be placed. That is the
			
 
				+    important half of the contract -- an unrecognised material is left exactly
			
 
				+    as it arrives rather than guessed at, so this can only ever fix a slot that
			
 
				+    was already wrong.
			
 
				+    """
			
 
				+    text = (material or "").strip()
			
 
				+    if not text:
			
 
				+        return ""
			
 
				+
			
 
				+    upper = text.upper()
			
 
				+    if upper in _PRINTER_TYPE_SET:
			
 
				+        return upper
			
 
				+    if upper in _TYPE_ALIASES:
			
 
				+        return _TYPE_ALIASES[upper]
			
 
				+
			
 
				+    words = [w for w in _WORDS.split(upper) if w]
			
 
				+
			
 
				+    # A hyphenated type written with a space is still that type. The table
			
 
				+    # spells it "PLA-AERO" because that is how the preset dropdown and the
			
 
				+    # slicers spell it, while a spool says "PLA Aero" and a preset name says
			
 
				+    # "Bambu PLA Aero" -- and the word rules below would find only the "PLA"
			
 
				+    # in those and hand back a slot that lies about what is loaded.
			
 
				+    #
			
 
				+    # Adjacent words only, and only when the join is a type exactly. The prefix
			
 
				+    # and suffix rules are deliberately not applied across a space: "Support
			
 
				+    # for PLA" would otherwise start reading as a type by its tail.
			
 
				+    for first, second in zip(words, words[1:], strict=False):
			
 
				+        joined = f"{first}-{second}"
			
 
				+        if joined in _PRINTER_TYPE_SET:
			
 
				+            return joined
			
 
				+        if joined in _TYPE_ALIASES:
			
 
				+            return _TYPE_ALIASES[joined]
			
 
				+
			
 
				+    for candidate in _TYPES_LONGEST_FIRST:
			
 
				+        if any(_word_names_type(w, candidate) for w in words):
			
 
				+            return _TYPE_ALIASES.get(candidate, candidate)
			
 
				+
			
 
				+    return text
			
 
				+
			
 
				+
			
 
				+def nozzle_temp_range(material: str | None, tray_type: str | None) -> tuple[int, int]:
			
 
				+    """The nozzle range to send with a slot, given a spool's material and the
			
 
				+    type the slot will carry.
			
 
				+
			
 
				+    The spool's own wording leads, as it does for the filament-id lookup, so a
			
 
				+    material that has its own entry keeps it. The reduced type answers for
			
 
				+    everything else -- and when the reduced type is a filled or foamed variant,
			
 
				+    the base material answers for that, because ``MATERIAL_TEMPS`` carries
			
 
				+    eleven entries and none of them is ASA-GF. Without that last step an
			
 
				+    ASA-GF spool took the 200/240 catch-all and would not have extruded;
			
 
				+    "ASA" gives it ASA's 240/270 (#2902).
			
 
				+    """
			
 
				+    base = (tray_type or "").split("-")[0]
			
 
				+    for key in (material, tray_type, base):
			
 
				+        temps = MATERIAL_TEMPS.get((key or "").upper().strip())
			
 
				+        if temps:
			
 
				+            return temps
			
 
				+    return (200, 240)
			
 
				+
			
 
				+
			
 
				+# Both tables are keyed by material, so their keys are exactly the set of names
			
 
				+# that are a material rather than a preset the printer can resolve.
			
 
				+_MATERIAL_NAMES = frozenset(MATERIAL_TEMPS) | frozenset(GENERIC_FILAMENT_IDS)
			
 
				+
			
 
				+# "GF" + letter + digits for Bambu's own presets, "P" + hex for local and cloud
			
 
				+# ones -- the shapes ``slicer_filament_resolver`` documents. Matched loosely on
			
 
				+# purpose: this only ever has to be sure a value is NOT a bare material name.
			
 
				+_PRESET_ID_SHAPE = re.compile(r"^(?:GF|P)[A-Za-z0-9_]*$")
			
 
				+
			
 
				+
			
 
				+def is_material_name(value: str | None) -> bool:
			
 
				+    """Whether a candidate filament id is really just a material name.
			
 
				+
			
 
				+    Two places ask this, and have to answer it the same way: the slicer-filament
			
 
				+    resolver, which throws such a value away so its caller's generic fallback
			
 
				+    can rescue the slot, and the slot-reuse check, which will not carry one
			
 
				+    forward. Both compared against the table above and so saw only bare types --
			
 
				+    but "PLA+" is exactly as unusable a filament id as the "PLA" they already
			
 
				+    rejected, and reaching the printer is how a product line ended up in the
			
 
				+    field the calibration table is keyed by (issue #2902).
			
 
				+
			
 
				+    A value shaped like a preset id is never a material name, whatever letters
			
 
				+    it happens to end in. Reading "GFPLA" as PLA would discard it, and what the
			
 
				+    user loses when that happens is the calibrated preset in the slot.
			
 
				+    """
			
 
				+    text = (value or "").strip()
			
 
				+    if not text:
			
 
				+        return False
			
 
				+    if text.upper() in _MATERIAL_NAMES:
			
 
				+        return True
			
 
				+    if _PRESET_ID_SHAPE.match(text):
			
 
				+        return False
			
 
				+    reduced = printer_filament_type(text).upper()
			
 
				+    if reduced in _MATERIAL_NAMES:
			
 
				+        return True
			
 
				+    # A filled or foamed variant is its base material by another name, and the
			
 
				+    # base is what decides. Saying yes means the caller throws this value away
			
 
				+    # and rescues the slot from its generic-material fallback -- so the answer
			
 
				+    # has to be no when that fallback has nothing to offer, or the slot goes out
			
 
				+    # with no filament id at all, which is worse than the junk it replaced.
			
 
				+    # ``ABS-GF`` reduces to a generic ABS the printer can resolve; ``PPS-CF``
			
 
				+    # reduces to nothing, so it is left for the caller to send as it stands.
			
 
				+    #
			
 
				+    # This is also what keeps a type added to the table above from silently
			
 
				+    # changing the answer: "PLA-AERO" read as a material name when the table
			
 
				+    # had no row for it, and it still does (#2902).
			
 
				+    return reduced.split("-")[0] in _MATERIAL_NAMES
			
--- a/backend/app/utils/fts_routing.py
+++ b/backend/app/utils/fts_routing.py
@@ -0,0 +1,76 @@
 
				+"""Which nozzle an AMS slot feeds, with or without a Filament Track Switch.
			
 
				+
			
 
				+K-profiles are per-nozzle, and the printer's calibration tables are numbered
			
 
				+per-nozzle too: ``cali_idx: 16`` means "entry 16 of whichever nozzle feeds this
			
 
				+tray". Without a switch that is unambiguous, because each AMS is wired to one
			
 
				+extruder and says so in its ``info`` bits. With a switch installed every AMS
			
 
				+reports 0xE instead and is bound to a switch *inlet*, so the answer has to come
			
 
				+from the inlet binding.
			
 
				+
			
 
				+Every caller that resolves a slot to an extruder should go through
			
 
				+``slot_extruder`` here. Three separate copies of that logic used to end in
			
 
				+``else 0``, which on a switch machine silently filed every profile under the
			
 
				+right-hand nozzle regardless of where the slot actually was.
			
 
				+
			
 
				+Kept as a leaf module with no imports of its own so the routes, the MQTT layer
			
 
				+and the scheduler can all share one answer.
			
 
				+"""
			
 
				+
			
 
				+# Which extruder each switch outlet terminates at. Measured on the maintainer's
			
 
				+# H2C, 2026-08-16: Out-A is the left hotend, Out-B is the right one.
			
 
				+#
			
 
				+# We would rather read this than assert it, but it is not in the telemetry:
			
 
				+# ``fila_switch.out`` reported ``[1, 1]`` unchanged across a 90-second capture,
			
 
				+# i.e. both outlets claiming the same extruder, which cannot describe real
			
 
				+# wiring. Whatever that field means, it is not outlet-to-nozzle.
			
 
				+#
			
 
				+# The inlet-to-outlet pairing then comes from the switch's un-crossed rest
			
 
				+# position: In-A -> Out-A, In-B -> Out-B. The switch does cross the two during a
			
 
				+# filament change, so this describes where a slot sits between prints, which is
			
 
				+# what a manual "configure this slot" task needs. It is deliberately one table
			
 
				+# to change if a machine turns up with its outlet tubes swapped.
			
 
				+FTS_INLET_EXTRUDER: dict[str, int] = {
			
 
				+    "A": 1,  # left / deputy
			
 
				+    "B": 0,  # right / main
			
 
				+}
			
 
				+
			
 
				+
			
 
				+def extruder_for_inlet(inlet: str | None) -> int | None:
			
 
				+    """Extruder fed by switch inlet ``"A"`` or ``"B"``; None for anything else."""
			
 
				+    if not inlet:
			
 
				+        return None
			
 
				+    return FTS_INLET_EXTRUDER.get(inlet.upper())
			
 
				+
			
 
				+
			
 
				+def slot_extruder(
			
 
				+    ams_id: int,
			
 
				+    tray_id: int,
			
 
				+    ams_extruder_map: dict | None,
			
 
				+    ams_switch_inlet: dict | None = None,
			
 
				+) -> int | None:
			
 
				+    """Resolve one AMS slot to the extruder it feeds, or None if unknowable.
			
 
				+
			
 
				+    Returns None rather than guessing. A single-nozzle printer has no map and no
			
 
				+    switch, and there the caller's own default of extruder 0 is correct — but on
			
 
				+    a dual-nozzle machine "I don't know" and "the right-hand nozzle" are very
			
 
				+    different answers, and conflating them is what bound a left-nozzle K-profile
			
 
				+    to a slot sitting on the right.
			
 
				+
			
 
				+    ``ams_id`` 255 is the external spool holder, where the tray id names the
			
 
				+    side directly: tray 0 is Ext-L (extruder 1) and tray 1 is Ext-R (extruder 0).
			
 
				+    """
			
 
				+    if ams_id == 255:
			
 
				+        return 1 - tray_id if tray_id in (0, 1) else None
			
 
				+
			
 
				+    # A real extruder id always wins. BambuStudio treats a non-0xE value as
			
 
				+    # authoritative too, so an AMS wired straight to one nozzle keeps that
			
 
				+    # binding even on a machine that has a switch fitted for its other units.
			
 
				+    if ams_extruder_map:
			
 
				+        mapped = ams_extruder_map.get(str(ams_id))
			
 
				+        if mapped is not None:
			
 
				+            return int(mapped)
			
 
				+
			
 
				+    if ams_switch_inlet:
			
 
				+        return extruder_for_inlet(ams_switch_inlet.get(str(ams_id)))
			
 
				+
			
 
				+    return None
			
--- a/backend/app/utils/http.py
+++ b/backend/app/utils/http.py
@@ -1,7 +1,43 @@
 
				 """HTTP response helpers."""
			
 
				 
			
 
				+from pathlib import Path
			
 
				 from urllib.parse import quote
			
 
				 
			
 
				+from starlette.responses import PlainTextResponse
			
 
				+
			
 
				+
			
 
				+def download_error_response(status_code: int, message: str) -> PlainTextResponse:
			
 
				+    """Answer a browser-native download with a file that says what went wrong.
			
 
				+
			
 
				+    These URLs are reached by an ``<a download>`` click, and a browser saves
			
 
				+    whatever comes back under the name it was going to use. A JSON error body
			
 
				+    therefore lands on the user's disk as a .zip that will not open, with
			
 
				+    nothing on screen to explain it -- the download simply appears to have
			
 
				+    produced a broken file. A short text file, named for the failure rather
			
 
				+    than for the download, is at least legible when opened.
			
 
				+    """
			
 
				+
			
 
				+    return PlainTextResponse(
			
 
				+        f"{message}\n",
			
 
				+        status_code=status_code,
			
 
				+        headers={"Content-Disposition": build_content_disposition("download-failed.txt")},
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+def safe_download_filename(filename: str, fallback: str = "download", max_chars: int = 200) -> str:
			
 
				+    """Return a basename safe for a bounded download response header."""
			
 
				+
			
 
				+    basename = Path(filename.replace("\\", "/")).name
			
 
				+    cleaned = "".join("_" if ord(char) < 32 or ord(char) == 127 else char for char in basename).strip(" .")
			
 
				+    if not cleaned:
			
 
				+        return fallback
			
 
				+    if len(cleaned) <= max_chars:
			
 
				+        return cleaned
			
 
				+    suffixes = "".join(Path(cleaned).suffixes)
			
 
				+    suffix = suffixes if len(suffixes) <= 32 else ""
			
 
				+    stem_chars = max(1, max_chars - len(suffix))
			
 
				+    return f"{cleaned[:stem_chars]}{suffix}"
			
 
				+
			
 
				 
			
 
				 def build_content_disposition(filename: str, disposition: str = "attachment") -> str:
			
 
				     """Build an RFC 6266-compliant Content-Disposition header value.
			
--- a/backend/app/utils/kprofile_lookup.py
+++ b/backend/app/utils/kprofile_lookup.py
@@ -0,0 +1,66 @@
 
				+"""Resolve an AMS slot's K value from the printer's calibration table.
			
 
				+
			
 
				+H2-series trays carry no ``k`` field of their own — only ``cali_idx`` — so the
			
 
				+K value on the AMS slot card (#2854) is looked up from the printer's
			
 
				+calibration table in ``state.kprofiles``. That table is not flat: the printer
			
 
				+numbers it **per nozzle**, so entry 16 exists under every nozzle it holds
			
 
				+profiles for and means a different profile on each.
			
 
				+
			
 
				+``state.kprofiles`` is the union across nozzle diameters (see
			
 
				+``BambuMQTTClient._store_kprofiles``), which is what the assign paths need but
			
 
				+makes ``cali_idx`` alone ambiguous. Resolution here is therefore:
			
 
				+
			
 
				+1. the slot's own extruder, which separates the two nozzles of a dual-nozzle
			
 
				+   machine outright;
			
 
				+2. failing that, the diameters currently installed, which separates a live
			
 
				+   table from one left behind by a nozzle that has since been swapped out.
			
 
				+
			
 
				+If both fail to single out one profile the answer is ``None``. A blank space on
			
 
				+the card is a smaller error than confidently printing the other nozzle's number.
			
 
				+"""
			
 
				+
			
 
				+from collections.abc import Callable
			
 
				+
			
 
				+from backend.app.utils.fts_routing import slot_extruder
			
 
				+
			
 
				+
			
 
				+def build_slot_k_resolver(state) -> Callable[[int | None, int, int], float | None]:
			
 
				+    """Return ``resolve(cali_idx, ams_id, tray_id) -> k value or None``.
			
 
				+
			
 
				+    Built once per serialization pass and closed over the state, so the REST
			
 
				+    and WebSocket views of the same card cannot answer differently.
			
 
				+    """
			
 
				+    # (extruder, cali_idx) -> {nozzle_diameter: k}. The inner dict is what
			
 
				+    # detects the ambiguity: more than one entry means two nozzles' tables both
			
 
				+    # claim this index on this extruder.
			
 
				+    table: dict[tuple[int, int], dict[str, float]] = {}
			
 
				+    for kp in getattr(state, "kprofiles", None) or []:
			
 
				+        if kp.slot_id is None or not kp.k_value:
			
 
				+            continue
			
 
				+        try:
			
 
				+            k_value = float(kp.k_value)
			
 
				+        except (ValueError, TypeError):
			
 
				+            continue  # Skip K-profile entries with unparseable values
			
 
				+        try:
			
 
				+            extruder = int(kp.extruder_id or 0)
			
 
				+        except (ValueError, TypeError):
			
 
				+            extruder = 0
			
 
				+        table.setdefault((extruder, kp.slot_id), {})[str(kp.nozzle_diameter or "")] = k_value
			
 
				+
			
 
				+    installed = {str(n.nozzle_diameter) for n in (getattr(state, "nozzles", None) or []) if n.nozzle_diameter}
			
 
				+
			
 
				+    def resolve(cali_idx: int | None, ams_id: int, tray_id: int) -> float | None:
			
 
				+        if cali_idx is None:
			
 
				+            return None
			
 
				+        extruder = slot_extruder(ams_id, tray_id, state.ams_extruder_map, state.ams_switch_inlet)
			
 
				+        # Single-nozzle printers report everything under extruder 0, and that
			
 
				+        # is also the right default when the routing is simply unknown.
			
 
				+        by_nozzle = table.get((extruder if extruder is not None else 0, cali_idx))
			
 
				+        if not by_nozzle:
			
 
				+            return None
			
 
				+        if len(by_nozzle) == 1:
			
 
				+            return next(iter(by_nozzle.values()))
			
 
				+        live = [k for nozzle, k in by_nozzle.items() if nozzle in installed]
			
 
				+        return live[0] if len(live) == 1 else None
			
 
				+
			
 
				+    return resolve
			
--- a/backend/app/utils/natural_sort.py
+++ b/backend/app/utils/natural_sort.py
@@ -0,0 +1,20 @@
 
				+"""Natural (numeric-aware) string sorting, e.g. "Drybox 2" before "Drybox 10"."""
			
 
				+
			
 
				+import re
			
 
				+
			
 
				+_CHUNK_RE = re.compile(r"(\d+)")
			
 
				+
			
 
				+
			
 
				+def natural_sort_key(value: str) -> tuple:
			
 
				+    """Sort key that orders embedded numbers by value, not lexicographically.
			
 
				+
			
 
				+    A plain string sort puts "Drybox 10" before "Drybox 2" (character by
			
 
				+    character, "1" < "2"). Splitting into alternating text/digit runs and
			
 
				+    comparing the digit runs as integers instead gets "Drybox 2" before
			
 
				+    "Drybox 10", without assuming every name follows a fixed "prefix N"
			
 
				+    shape. `_CHUNK_RE.split` always yields text chunks at even indices and
			
 
				+    digit chunks at odd indices for any input, so the type at a given index
			
 
				+    is consistent across every key this function produces — two keys can be
			
 
				+    compared without ever hitting a str-vs-int mismatch mid-tuple.
			
 
				+    """
			
 
				+    return tuple(int(chunk) if chunk.isdigit() else chunk.lower() for chunk in _CHUNK_RE.split(value))
			
--- a/backend/app/utils/print_jobs.py
+++ b/backend/app/utils/print_jobs.py
@@ -0,0 +1,82 @@
 
				+"""Telling the printer's own internal jobs apart from a user's print.
			
 
				+
			
 
				+Bambu firmware runs jobs on its own behalf -- bed levelling, vibration
			
 
				+compensation, the pressure-advance line it lays down before a print when flow
			
 
				+dynamics calibration is on -- and reports them over MQTT through exactly the
			
 
				+same print-start and print-complete events a real print uses. Nothing about the
			
 
				+event says "this one is mine": Bambuddy has to recognise the job by name.
			
 
				+
			
 
				+Getting that wrong is not free. An unrecognised calibration run has no 3MF
			
 
				+anywhere on the printer, so the archive path sweeps FTP for a file that cannot
			
 
				+exist -- six candidate names across five directories, with retries -- and then
			
 
				+writes a no-3MF archive named after the calibration, on a printer that is in
			
 
				+the middle of calibrating.
			
 
				+
			
 
				+Kept as a leaf module with no imports of its own so both the print-start and
			
 
				+print-complete callbacks can share one answer.
			
 
				+"""
			
 
				+
			
 
				+# Job names the printer runs for itself. Matched exactly (after normalising),
			
 
				+# not by prefix or substring: "auto" and "calib" are ordinary words in a user's
			
 
				+# own filenames, and a rule loose enough to catch an unnamed future calibration
			
 
				+# would silently swallow somebody's print.
			
 
				+#
			
 
				+# ``auto_cali_for_user`` is the bed-levelling / vibration run, normally reported
			
 
				+# with a ``/usr/etc/print/`` path that the rule below catches on its own; it is
			
 
				+# listed anyway because the path is not guaranteed and a name-only report of it
			
 
				+# would otherwise slip through.
			
 
				+#
			
 
				+# ``auto_pa_line_calib_mode`` is the pressure-advance (K profile) line. This one
			
 
				+# is reported as a *subtask name* with no ``/usr/`` path at all, which is why
			
 
				+# the path rule alone was never enough.
			
 
				+#
			
 
				+# ``pa_line_calib_mode`` and ``pa_pattern_calib_mode`` are the same calibration
			
 
				+# started by hand rather than automatically before a print. Manual flow dynamics
			
 
				+# offers both shapes -- a line and a pattern -- and each reports under its own
			
 
				+# name with no ``auto_`` prefix, so neither is covered by the automatic entry
			
 
				+# above and both produced the same no-3MF archive. They are listed as two
			
 
				+# literals rather than matched by a shared ``pa_`` stem for the reason the whole
			
 
				+# set is exact: a stem rule would also swallow a user's own ``pa_bracket.3mf``.
			
 
				+INTERNAL_JOB_NAMES = frozenset(
			
 
				+    {
			
 
				+        "auto_cali_for_user",
			
 
				+        "auto_pa_line_calib_mode",
			
 
				+        "pa_line_calib_mode",
			
 
				+        "pa_pattern_calib_mode",
			
 
				+    }
			
 
				+)
			
 
				+
			
 
				+# Longest first: ``.gcode.3mf`` has to be stripped whole, or ``.3mf`` would
			
 
				+# match first and leave a trailing ``.gcode`` behind.
			
 
				+_PRINT_SUFFIXES = (".gcode.3mf", ".gcode", ".3mf")
			
 
				+
			
 
				+
			
 
				+def _normalize_job_name(value: str) -> str:
			
 
				+    """Reduce a reported name to something comparable against the set above.
			
 
				+
			
 
				+    Drops any directory part, one print-file suffix, and case. The printer is
			
 
				+    not consistent about which of these it includes -- the same calibration
			
 
				+    reports as a bare name in ``subtask_name`` and, when it appears at all, as
			
 
				+    a full path in ``gcode_file``.
			
 
				+    """
			
 
				+    name = value.rsplit("/", 1)[-1].rsplit("\\", 1)[-1].strip().casefold()
			
 
				+    for suffix in _PRINT_SUFFIXES:
			
 
				+        if name.endswith(suffix):
			
 
				+            return name[: -len(suffix)]
			
 
				+    return name
			
 
				+
			
 
				+
			
 
				+def is_internal_printer_job(filename: str | None, subtask_name: str | None = None) -> bool:
			
 
				+    """True when this print event belongs to the printer, not to a user.
			
 
				+
			
 
				+    Both fields are tested because neither is reliably populated: the
			
 
				+    pressure-advance line arrives as a subtask name with no filename, while the
			
 
				+    levelling run arrives as a ``/usr/etc/print/...`` path. A job is internal if
			
 
				+    *either* field says so.
			
 
				+    """
			
 
				+    if filename and filename.startswith("/usr/"):
			
 
				+        # Bambu keeps its own calibration gcode on the read-only system
			
 
				+        # partition. Nothing a user can print ever lives there, so the whole
			
 
				+        # prefix is safe to treat as internal without naming each file.
			
 
				+        return True
			
 
				+    return any(_normalize_job_name(value) in INTERNAL_JOB_NAMES for value in (filename, subtask_name) if value)
			
--- a/backend/app/utils/threemf_tools.py
+++ b/backend/app/utils/threemf_tools.py
@@ -1025,6 +1025,96 @@ def extract_bed_type_from_3mf(file_path: Path, plate_id: int | None = None) -> s
 
				     return extract_plate_metadata_from_3mf(file_path, plate_id).bed_type
			
 
				 
			
 
				 
			
 
				+# Bed temperature is not one key in a BambuStudio project. Every plate type has
			
 
				+# its own per-filament array, and the plate actually fitted is named separately
			
 
				+# in ``curr_bed_type`` -- so reading a bed temperature means picking the array
			
 
				+# the plate points at. Keys and mapping are BambuStudio's own
			
 
				+# ``get_bed_temp_1st_layer_key`` / ``get_bed_temp_key`` (PrintConfig.hpp), and
			
 
				+# the plate names are the ``curr_bed_type`` enum values (PrintConfig.cpp).
			
 
				+# First-layer temperature first: that is what the printer heats to before the
			
 
				+# print starts, which is what preheat is trying to reach.
			
 
				+#
			
 
				+# ``Default Plate`` is deliberately absent -- BambuStudio maps it to no key at
			
 
				+# all, so there is nothing to read and guessing a plate would invent a bed
			
 
				+# temperature the slice never specified.
			
 
				+_BED_TEMP_KEYS: dict[str, tuple[str, str]] = {
			
 
				+    "Cool Plate": ("cool_plate_temp_initial_layer", "cool_plate_temp"),
			
 
				+    "Engineering Plate": ("eng_plate_temp_initial_layer", "eng_plate_temp"),
			
 
				+    "High Temp Plate": ("hot_plate_temp_initial_layer", "hot_plate_temp"),
			
 
				+    "Textured PEI Plate": ("textured_plate_temp_initial_layer", "textured_plate_temp"),
			
 
				+    "Supertack Plate": ("supertack_plate_temp_initial_layer", "supertack_plate_temp"),
			
 
				+}
			
 
				+
			
 
				+# Fallback for a config that names no plate: the Orca/PrusaSlicer spelling,
			
 
				+# which is a single value rather than a per-plate array.
			
 
				+_GENERIC_BED_TEMP_KEYS = ("bed_temperature_initial_layer", "bed_temperature")
			
 
				+
			
 
				+
			
 
				+def _plate_temperature(val) -> int | None:
			
 
				+    """Bed temperature from one plate-temperature entry, or None.
			
 
				+
			
 
				+    The plate arrays carry one entry per filament in the project, and a 0 means
			
 
				+    that filament cannot print on this plate. The bed only has one temperature,
			
 
				+    so the print runs at the highest its filaments ask for -- taking entry 0 the
			
 
				+    way the neighbouring scalar settings do would store a 0 for any project
			
 
				+    whose first filament is not one this plate is heated for.
			
 
				+    """
			
 
				+    values = val if isinstance(val, list) else [val]
			
 
				+    temps = []
			
 
				+    for entry in values:
			
 
				+        if isinstance(entry, bool) or not isinstance(entry, (int, float, str)):
			
 
				+            continue
			
 
				+        try:
			
 
				+            temps.append(int(float(entry)))
			
 
				+        except (TypeError, ValueError):
			
 
				+            continue
			
 
				+    return max(temps) if temps else None
			
 
				+
			
 
				+
			
 
				+def bed_temperature_from_config(data: dict) -> int | None:
			
 
				+    """Bed temperature for the plate *data* is sliced for, or None (#2989).
			
 
				+
			
 
				+    *data* is a parsed ``Metadata/project_settings.config``. Lives here rather
			
 
				+    than beside the archive parser so the ingest path and the one-shot backfill
			
 
				+    that repairs archives written before the fix read it exactly the same way.
			
 
				+    """
			
 
				+    bed_type = str(data.get("curr_bed_type") or "").strip()
			
 
				+    for key in (*_BED_TEMP_KEYS.get(bed_type, ()), *_GENERIC_BED_TEMP_KEYS):
			
 
				+        if key not in data:
			
 
				+            continue
			
 
				+        temperature = _plate_temperature(data[key])
			
 
				+        # A plate array of all zeros means no filament in the project prints on
			
 
				+        # this plate, which is not a bed temperature -- keep looking rather than
			
 
				+        # recording a 0 that reads as "cold bed".
			
 
				+        if temperature:
			
 
				+            return temperature
			
 
				+    return None
			
 
				+
			
 
				+
			
 
				+def extract_bed_temperature_from_3mf(file_path: Path) -> int | None:
			
 
				+    """Read a 3MF's bed temperature straight off disk, or None.
			
 
				+
			
 
				+    For the backfill, which has a ``file_path`` and nothing else. Opens only
			
 
				+    ``Metadata/project_settings.config`` -- the archive parser reads thumbnails,
			
 
				+    the model and the slice info as well, and none of that is wanted here.
			
 
				+
			
 
				+    Every failure is None. Deliberately broader than the handful of exceptions a
			
 
				+    malformed zip is expected to raise: the caller runs inside the startup
			
 
				+    migration, which has no handler above it, so anything unlisted escaping here
			
 
				+    does not skip one archive -- it stops Bambuddy from booting, and keeps
			
 
				+    stopping it, because the one-shot flag is written in the same transaction
			
 
				+    that just rolled back. A bed temperature is not worth that.
			
 
				+    """
			
 
				+    try:
			
 
				+        with zipfile.ZipFile(file_path, "r") as zf:
			
 
				+            if "Metadata/project_settings.config" not in zf.namelist():
			
 
				+                return None
			
 
				+            data = json.loads(zf.read("Metadata/project_settings.config").decode())
			
 
				+        return bed_temperature_from_config(data) if isinstance(data, dict) else None
			
 
				+    except Exception:
			
 
				+        return None
			
 
				+
			
 
				+
			
 
				 # Header values exposed as `{placeholder}` substitutions inside snippets.
			
 
				 # Aliases let users write Prusa-style names (`{max_layer_z}`) that map onto
			
 
				 # Bambu/Orca header keys (`max_z_height`).
			
@@ -1120,6 +1210,39 @@ def default_plate_gcode_name(names: list[str]) -> str | None:
 
				     return gcodes[0]
			
 
				 
			
 
				 
			
 
				+def names_carry_gcode(names: list[str]) -> bool:
			
 
				+    """Is this 3MF a sliced file — does it carry printer-executable G-code?
			
 
				+
			
 
				+    One definition, because several of them is the bug (#2993). The archive
			
 
				+    side judged a file by what it holds -- the card's GCODE badge reads the
			
 
				+    layer count and print time parsed out of the plate G-code, and
			
 
				+    ``/archives/{id}/capabilities`` scanned the zip -- while the library judged
			
 
				+    it by its filename. So a sliced 3MF stored as ``Foo.3mf`` rather than
			
 
				+    ``Foo.gcode.3mf`` carried the badge and still re-imported as a source-only
			
 
				+    project. This is the answer for anything asking the zip directly.
			
 
				+
			
 
				+    Defers to ``default_plate_gcode_name`` rather than testing for
			
 
				+    ``Metadata/plate_<n>.gcode``, so a slicer that lays its output out some
			
 
				+    other way is judged by the same rule everywhere.
			
 
				+    """
			
 
				+    return default_plate_gcode_name(names) is not None
			
 
				+
			
 
				+
			
 
				+def carries_gcode(file_path: Path | str) -> bool:
			
 
				+    """``names_carry_gcode`` for a file on disk. False for anything unreadable.
			
 
				+
			
 
				+    Only the zip's central directory is read — no member is decompressed — so
			
 
				+    this is cheap enough to run on every ingested file.
			
 
				+    """
			
 
				+    try:
			
 
				+        with zipfile.ZipFile(file_path, "r") as zf:
			
 
				+            return names_carry_gcode(zf.namelist())
			
 
				+    except (OSError, zipfile.BadZipFile):
			
 
				+        # Not a zip, gone, or unreadable. Callers treat that as "no G-code
			
 
				+        # visible", which is what they did before this check existed.
			
 
				+        return False
			
 
				+
			
 
				+
			
 
				 # The header block sits at the very top of the plate G-code. Read only that
			
 
				 # much: a sliced plate is routinely tens of megabytes and `ZipFile.read()`
			
 
				 # would inflate all of it to reach ~40 lines.
			
--- a/backend/tests/conftest.py
+++ b/backend/tests/conftest.py
@@ -167,6 +167,33 @@ def reset_auth_enabled_cache():
 
				     invalidate_auth_enabled_cache()
			
 
				 
			
 
				 
			
 
				+@pytest.fixture(autouse=True)
			
 
				+def disconnect_printers_registered_during_a_test():
			
 
				+    """Give every test an empty ``printer_manager`` singleton.
			
 
				+
			
 
				+    ``POST /api/v1/printers`` really calls ``connect_printer``, so a test that
			
 
				+    creates a printer through the API parks a live client in the singleton --
			
 
				+    and the singleton outlives the per-test in-memory database. The next test
			
 
				+    on the same xdist worker gets a fresh database whose first printer is handed
			
 
				+    the same primary key, and reads that leftover client as its own live status.
			
 
				+    ``test_scheduled_drying_routes`` saw exactly that: an "online" printer with
			
 
				+    no firmware version, so scheduling a dry came back 400 instead of 200.
			
 
				+
			
 
				+    Snapshotting the ids at test entry was insufficient: a client leaked by a
			
 
				+    previous module became part of that snapshot and therefore survived every
			
 
				+    later cleanup on the same xdist worker. Clear both before and after each
			
 
				+    test. ``disconnect_printer`` also clears model/printer-info caches and stops
			
 
				+    any paho thread owned by the leaked client.
			
 
				+    """
			
 
				+    from backend.app.services.printer_manager import printer_manager
			
 
				+
			
 
				+    for printer_id in list(printer_manager._clients):
			
 
				+        printer_manager.disconnect_printer(printer_id)
			
 
				+    yield
			
 
				+    for printer_id in list(printer_manager._clients):
			
 
				+        printer_manager.disconnect_printer(printer_id)
			
 
				+
			
 
				+
			
 
				 @pytest.fixture(scope="session")
			
 
				 def event_loop():
			
 
				     """Create an instance of the default event loop for each test session."""
			
@@ -208,6 +235,7 @@ async def test_engine():
 
				         printer,
			
 
				         project,
			
 
				         project_bom,
			
 
				+        scheduled_drying,
			
 
				         settings,
			
 
				         slot_preset,
			
 
				         smart_plug,
			
@@ -216,6 +244,7 @@ async def test_engine():
 
				         spool,
			
 
				         spool_assignment,
			
 
				         spool_catalog,
			
 
				+        spool_filament_preset,
			
 
				         spool_k_profile,
			
 
				         spool_usage_history,
			
 
				         spoolbuddy_device,
			
@@ -560,6 +589,32 @@ def printer_factory(db_session):
 
				     return _create_printer
			
 
				 
			
 
				 
			
 
				+@pytest.fixture
			
 
				+def location_factory(db_session):
			
 
				+    _counter = [0]
			
 
				+
			
 
				+    async def _create_location(**kwargs):
			
 
				+        from backend.app.models.location import Location
			
 
				+
			
 
				+        _counter[0] += 1
			
 
				+        counter = _counter[0]
			
 
				+
			
 
				+        name = kwargs.pop("name", f"Test Location {counter}")
			
 
				+        defaults = {
			
 
				+            "name": name,
			
 
				+            "name_key": name.strip().lower(),
			
 
				+        }
			
 
				+        defaults.update(kwargs)
			
 
				+
			
 
				+        location = Location(**defaults)
			
 
				+        db_session.add(location)
			
 
				+        await db_session.commit()
			
 
				+        await db_session.refresh(location)
			
 
				+        return location
			
 
				+
			
 
				+    return _create_location
			
 
				+
			
 
				+
			
 
				 @pytest.fixture
			
 
				 def notification_provider_factory(db_session):
			
 
				     """Factory to create test notification providers."""
			
--- a/backend/tests/integration/test_ams_drying_latch_persistence.py
+++ b/backend/tests/integration/test_ams_drying_latch_persistence.py
@@ -0,0 +1,136 @@
 
				+"""The AMS drying latch has to survive a backend restart (#1802).
			
 
				+
			
 
				+Suppression of the high-temperature alarm spans a drying cycle plus the
			
 
				+cool-down after it, which together can run well over twelve hours. Holding that
			
 
				+purely in memory — as the sibling ``_ams_alarm_cooldown`` dict does — meant any
			
 
				+restart partway through resumed alarming about heat the user asked for, so the
			
 
				+latch is stored in the settings table instead.
			
 
				+"""
			
 
				+
			
 
				+import json
			
 
				+from datetime import datetime, timedelta, timezone
			
 
				+
			
 
				+import pytest
			
 
				+from sqlalchemy import select
			
 
				+
			
 
				+from backend.app.main import (
			
 
				+    AMS_DRYING_GRACE_MINUTES,
			
 
				+    AMS_DRYING_LATCH_KEY,
			
 
				+    _load_ams_drying_latch,
			
 
				+    _save_ams_drying_latch,
			
 
				+)
			
 
				+from backend.app.models.settings import Settings
			
 
				+
			
 
				+
			
 
				+async def _stored_value(db_session) -> str | None:
			
 
				+    result = await db_session.execute(select(Settings).where(Settings.key == AMS_DRYING_LATCH_KEY))
			
 
				+    setting = result.scalar_one_or_none()
			
 
				+    return setting.value if setting else None
			
 
				+
			
 
				+
			
 
				+@pytest.mark.asyncio
			
 
				+class TestAmsDryingLatchPersistence:
			
 
				+    async def test_round_trip_survives_a_reload(self, db_session):
			
 
				+        stamp = datetime.now(timezone.utc) - timedelta(minutes=10)
			
 
				+        await _save_ams_drying_latch(db_session, {"1:0": stamp})
			
 
				+        await db_session.commit()
			
 
				+
			
 
				+        # A fresh load is what a restarted backend does on its first pass.
			
 
				+        assert await _load_ams_drying_latch(db_session) == {"1:0": stamp}
			
 
				+
			
 
				+    async def test_no_row_created_when_nothing_ever_dries(self, db_session):
			
 
				+        await _save_ams_drying_latch(db_session, {})
			
 
				+        await db_session.commit()
			
 
				+        assert await _stored_value(db_session) is None
			
 
				+        assert await _load_ams_drying_latch(db_session) == {}
			
 
				+
			
 
				+    async def test_existing_row_is_updated_not_duplicated(self, db_session):
			
 
				+        first = datetime.now(timezone.utc) - timedelta(minutes=30)
			
 
				+        second = datetime.now(timezone.utc)
			
 
				+        await _save_ams_drying_latch(db_session, {"1:0": first})
			
 
				+        await db_session.commit()
			
 
				+        await _save_ams_drying_latch(db_session, {"1:0": second})
			
 
				+        await db_session.commit()
			
 
				+
			
 
				+        result = await db_session.execute(select(Settings).where(Settings.key == AMS_DRYING_LATCH_KEY))
			
 
				+        assert len(result.scalars().all()) == 1
			
 
				+        assert await _load_ams_drying_latch(db_session) == {"1:0": second}
			
 
				+
			
 
				+    async def test_clearing_the_latch_empties_the_row(self, db_session):
			
 
				+        await _save_ams_drying_latch(db_session, {"1:0": datetime.now(timezone.utc)})
			
 
				+        await db_session.commit()
			
 
				+        await _save_ams_drying_latch(db_session, {})
			
 
				+        await db_session.commit()
			
 
				+
			
 
				+        assert await _stored_value(db_session) == "{}"
			
 
				+        assert await _load_ams_drying_latch(db_session) == {}
			
 
				+
			
 
				+    async def test_multiple_units_are_tracked_independently(self, db_session):
			
 
				+        now = datetime.now(timezone.utc)
			
 
				+        latch = {"1:0": now - timedelta(minutes=5), "1:1": now, "2:128": now - timedelta(minutes=15)}
			
 
				+        await _save_ams_drying_latch(db_session, latch)
			
 
				+        await db_session.commit()
			
 
				+        assert await _load_ams_drying_latch(db_session) == latch
			
 
				+
			
 
				+    async def test_entries_past_the_grace_cap_are_dropped_on_load(self, db_session):
			
 
				+        now = datetime.now(timezone.utc)
			
 
				+        fresh = now - timedelta(minutes=5)
			
 
				+        stale = now - timedelta(minutes=AMS_DRYING_GRACE_MINUTES + 30)
			
 
				+        await _save_ams_drying_latch(db_session, {"1:0": fresh, "9:3": stale})
			
 
				+        await db_session.commit()
			
 
				+
			
 
				+        # The stale one would expire on its next visit anyway; dropping it here
			
 
				+        # keeps rows for deleted printers from accumulating forever.
			
 
				+        assert await _load_ams_drying_latch(db_session) == {"1:0": fresh}
			
 
				+
			
 
				+    async def test_wildly_future_stamps_are_dropped(self, db_session):
			
 
				+        # A box whose clock jumps backwards (a Pi coming up before NTP) would
			
 
				+        # otherwise hold the alarm suppressed until real time caught up.
			
 
				+        future = datetime.now(timezone.utc) + timedelta(hours=6)
			
 
				+        await _save_ams_drying_latch(db_session, {"1:0": future})
			
 
				+        await db_session.commit()
			
 
				+        assert await _load_ams_drying_latch(db_session) == {}
			
 
				+
			
 
				+    async def test_near_future_stamps_are_clamped_to_now(self, db_session):
			
 
				+        # Small backwards skew survives as a latch, but must not sit ahead of
			
 
				+        # now: suppression is measured as now minus the stamp, so a future one
			
 
				+        # would run for the skew on top of the cap instead of the cap alone.
			
 
				+        before = datetime.now(timezone.utc)
			
 
				+        await _save_ams_drying_latch(db_session, {"1:0": before + timedelta(minutes=30)})
			
 
				+        await db_session.commit()
			
 
				+
			
 
				+        loaded = await _load_ams_drying_latch(db_session)
			
 
				+        assert set(loaded) == {"1:0"}
			
 
				+        assert before <= loaded["1:0"] <= datetime.now(timezone.utc)
			
 
				+
			
 
				+    async def test_corrupt_row_reads_as_no_latch(self, db_session):
			
 
				+        db_session.add(Settings(key=AMS_DRYING_LATCH_KEY, value="{not json"))
			
 
				+        await db_session.commit()
			
 
				+        # Degrades to the pre-#1802 behaviour rather than crashing the recorder.
			
 
				+        assert await _load_ams_drying_latch(db_session) == {}
			
 
				+
			
 
				+    async def test_non_object_json_reads_as_no_latch(self, db_session):
			
 
				+        db_session.add(Settings(key=AMS_DRYING_LATCH_KEY, value="[1, 2, 3]"))
			
 
				+        await db_session.commit()
			
 
				+        assert await _load_ams_drying_latch(db_session) == {}
			
 
				+
			
 
				+    async def test_unparseable_stamps_are_skipped_individually(self, db_session):
			
 
				+        good = datetime.now(timezone.utc) - timedelta(minutes=3)
			
 
				+        db_session.add(
			
 
				+            Settings(
			
 
				+                key=AMS_DRYING_LATCH_KEY,
			
 
				+                value=json.dumps({"1:0": good.isoformat(), "1:1": "yesterday"}),
			
 
				+            )
			
 
				+        )
			
 
				+        await db_session.commit()
			
 
				+        assert await _load_ams_drying_latch(db_session) == {"1:0": good}
			
 
				+
			
 
				+    async def test_naive_stamps_are_read_as_utc(self, db_session):
			
 
				+        # SQLite hands back naive datetimes elsewhere in the app, so a hand-edited
			
 
				+        # or migrated value without an offset must not raise on comparison.
			
 
				+        naive = (datetime.now(timezone.utc) - timedelta(minutes=7)).replace(tzinfo=None)
			
 
				+        db_session.add(Settings(key=AMS_DRYING_LATCH_KEY, value=json.dumps({"1:0": naive.isoformat()})))
			
 
				+        await db_session.commit()
			
 
				+
			
 
				+        loaded = await _load_ams_drying_latch(db_session)
			
 
				+        assert loaded == {"1:0": naive.replace(tzinfo=timezone.utc)}