Fix AMS gradient rendering, color presets and printer writeback (#16252 )

* Fix external spool gradient and multicolor rendering * Display AMS gradients and multicolors in color popup * Preserve AMS gradient selection through color popup * Match popup selections by full filament color data * Align AMS Lite gradient geometry with BambuStudio * Align AMS color palette with BambuStudio presets * Match Bambu circular color rendering without background masks * Preserve AMS gradient colors when applying filament settings * Match AMS preview gradient swatches to the solid color shape
Complete traditional Chinese translations (#16513 )
2026-10-15 11:51:33 +00:00 · 2026-10-15 19:43:07 +08:00 · 2026-10-15 19:32:54 +08:00 · 2026-10-15 19:32:30 +08:00 · 2026-10-15 14:14:26 +03:00 · 2026-10-15 07:30:57 -03:00
86 changed files with 42104 additions and 9203 deletions
@@ -1,199 +0,0 @@
-# Multi-extruder and multi-AMS device control
-
-`DeviceManager`/`MachineObject` model the toolheads, AMS units, and filament slots of a connected
-printer and drive the device-control UI from that model. The model represents the counts as
-device-reported runtime values rather than compile-time caps, so a printer with an arbitrary number
-of toolheads, several AMS units, and a non-uniform number of slots per unit is handled by the same
-code paths. The printer agent is responsible for translating its printer's state into the shared
-JSON dialect this model consumes; the agent boundary is described in
-[printer-agent.md](printer-agent.md), and this document describes the dialect and the model.
-
-## Model layout
-
-`MachineObject` owns the device subsystems that this document covers:
-
- `DevExtderSystem` — the toolheads (extruders) and their per-toolhead filament/temperature state.
- `DevFilaSystem` — the AMS units (`DevAms`) and their trays (`DevAmsTray`).
- `DevNozzleSystem` — the nozzles and, on rack printers, `DevNozzleRack`.
- `DevFilaSwitch` — a filament switch that can feed several AMS units to more than one extruder.
-
-Each subsystem exposes its own count — `DevExtderSystem::GetTotalExtderCount()`,
-`DevFilaSystem::GetAmsCount()`, `DevAms::GetSlotCount()` — and the rest of the application derives
-its layout from those values rather than from fixed assumptions.
-
-## Wire dialect
-
-The dialect is the Bambu-shaped JSON that `DeviceManager` and `MachineObject` already consume. An
-agent whose printer speaks something else is expected to translate into it; the agent is not free
-to invent a new shape. Two representations coexist for extruders, and one for AMS/slots.
-
-### Extruders
-
-The generic representation is `print.device.extruder`, parsed by
-`ExtderSystemParser::ParseV2_0` (`DevExtruderSystem.cpp`). It has a packed `state` integer and an
-`info` array with one object per toolhead:
-
-```text
-device.extruder.state           packed integer
-  bits  0..3   total extruder count
-  bits  4..7   current extruder id
-  bits  8..11  target extruder id
-  bits 12..14  switch state
-  bits 15..18  currently loading extruder id
-  bit   19     busy for loading
-
-device.extruder.info[]          one entry per toolhead
-  id          extruder id
-  filam_bak   array of backup-group bits
-  info        bit 1 has filament, bit 2 buffer has filament, bit 3 nozzle present
-  temp        bits 0..15 current temperature, bits 16..31 target temperature
-  spre        slot_id bits 0..7, ams_id bits 8..15 (previous)
-  snow        same packing (current)
-  star        same packing (target)
-  stat        bit 0..15 AMS status, bits 16..31 RFID status
-  hnow        current nozzle id
-```
-
-The legacy single/dual representation is the pair of scalar fields `nozzle_temper` /
-`nozzle_target_temper`, plus the `print.ams.tray_tar` / `tray_now` tray pointer, parsed by
-`ExtderSystemParser::ParseV1_0`. That parser is a fallback and only fills the main extruder when the
-reported toolhead count is one.
-
-Physical extruder ids are fixed (`MAIN_EXTRUDER_ID = 0`, `DEPUTY_EXTRUDER_ID = 1`). Bambu printers
-present the two toolheads as a left/right pair and invert the physical-to-logical mapping; generic
-printers use the toolhead id itself as the logical id. `DevNozzle::GetLogicExtruderId()` /
-`GetExtruderId()` centralise that distinction.
-
-### AMS units and slots
-
-AMS units arrive as `print.ams.ams[]` and are parsed by `DevFilaSystemParser::ParseV1_0`. Each unit
-carries an `id` and an `info` bitfield:
-
-```text
-info bits  0..3    type: 0 dummy, 1 AMS, 2 AMS-Lite, 3 N3F, 4 N3S, 5 AMS-Lite-mixed (N9)
-info bits  8..11   bound extruder id (0xE marks a switch-bound unit)
-info bits 24..27   switch inlet when the unit is switch-bound
-```
-
-`DevAmsType` (`DevDefs.h`) enumerates the resulting unit kinds: `EXT_SPOOL`, `AMS`, `AMS_LITE`,
-`N3F`, `N3S`, and the `AMS_LITE_MIXED` N9 variant. `AMS_LITE_MIXED` reports itself as `AMS_LITE` to
-generic callers; code that needs the distinction uses `IsAmsLiteMixed()`.
-
-A unit whose bound-extruder nibble is `0xE` is switch-bound: it is kept only when a `DevFilaSwitch`
-is installed, in which case its extruder id is pinned to the main extruder and its binding set
-becomes `{0, 1}`; otherwise the unit is dropped from the AMS list.
-
-Each unit owns a map of `DevAmsTray` keyed by the tray id from the payload. The slot count is a
-property of the unit kind and the reported trays:
-
- `AMS`, `AMS_LITE`, and `N3F` report four slots on Bambu printers, matching the firmware contract;
- `N3S` reports one slot;
- `EXT_SPOOL` and any non-Bambu unit report the number of trays actually present.
-
-The tray ids are the payload's slot indices; they are expected to be unique, 0-based, and contiguous
-within a unit, because the generic tray-index mapping below is cumulative.
-
-Bulk/extended spools are carried by `print.vir_slot`, which `DeviceManager` parses into
-`MachineObject::vt_slot`. Two ids are fixed: `VIRTUAL_TRAY_MAIN_ID = 255` (extruder 0) and
-`VIRTUAL_TRAY_DEPUTY_ID = 254` (extruder 1); the id convention is `vt_id = 255 - extruder_id`, so
-further extruders use 253, 252, … . The `vir_slot` parser recognises the 255/254 pair; the agent
-filament descriptor path `DevFilaSystemParser::ParseAgentFilament` is the entry that stores a fuller
-descending set in `vt_slot`.
-
-## Mapping
-
-Several subsystems relate AMS units, trays, and extruders, and more than one place derives a tray
-index. The Bambu mapping path (`DevMappingUtil`) computes `ams_id * 4 + slot_id` and knows only the
-Bambu unit kinds; `DevFilaSystem` provides the device model's own mapping below. The two agree for
-Bambu units and diverge for a non-Bambu unit whose slot count is not four.
-
-### AMS id to extruder id
-
-`DevFilaSystem::GetExtruderIdByAmsId()` resolves an AMS id to the extruder it feeds:
-
- an AMS unit returns its bound extruder (`DevAms::GetExtruderId()`);
- a virtual tray returns `VIRTUAL_TRAY_MAIN_ID - vt_id`;
- Bambu's virtual AMS ids map to the main/deputy extruder.
-
-A unit may be bound to more than one extruder when a `DevFilaSwitch` feeds it; the binding set
-(`DevAms::m_binded_extruder_set`) and switch inlet are read by switch-aware code while the
-single-extruder id stays pinned for legacy callers.
-
-### Tray index
-
-`DevFilaSystem::GetTrayIndexMap()` maps a global tray index to an `(ams_id, slot_id)` pair and is
-used for backup-slot translation, calibration addressing, and the mapping popups.
-
- Bambu AMS: `ams_id * 4 + slot_id`; N3S: the AMS id; AMS-Lite-mixed (N9): `24 + slot_id`.
- Generic (non-Bambu): a running lane index — the count of trays in preceding units plus the slot
-  id. This depends on each unit's tray ids being 0-based and contiguous.
-
-### Virtual-slot recognition
-
-`devPrinterUtil::IsVirtualSlot()` decides whether an id denotes a virtual tray. On Bambu printers it
-is the fixed pair `{255, 254}`. On generic printers it is the descending range
-`[255 - count + 1, 255]`, where `count` is the selected printer preset's extruder count. The preset
-is expected to match the connected device; when the two disagree the virtual range is wrong, which
-is why a mismatch is reported rather than silently accepted.
-
-## Device-control UI
-
-The device-control widgets follow the same device-reported counts.
-
- `AMSModel` (`AMSItem.hpp`) mirrors `DevAmsType` numerically: `EXT_AMS`, `GENERIC_AMS`, `AMS_LITE`,
-  `N3F_AMS`, `N3S_AMS`. A plain `AMS` maps to `GENERIC_AMS`.
- On non-Bambu printers `use_generic_ams_layout()` routes `GENERIC_AMS` units through a variable-lane
-  rendering that draws one lane per reported tray; Bambu keeps its fixed four-slot rendering.
- `AMSControl` picks its layout by toolhead count, not vendor: `CreateAmsSingleNozzle` for one
-  toolhead, `CreateAmsDoubleNozzle` for two, and `CreateAmsMultiNozzle` (one preview and one AMS
-  simplebook per toolhead) for three or more. A two-toolhead generic printer therefore keeps the
-  legacy left/right presentation; that is deliberate.
- The status panel's `ExtruderImage` renders one per-toolhead state per nozzle and is resized to
-  `GetTotalExtderCount()`. Non-Bambu printers choose the active toolhead through
-  `m_generic_nozzle_selector` (shown when more than one toolhead exists); Bambu keeps its left/right
-  `m_nozzle_btn_panel`. Nozzle temperature controls are created on demand per toolhead.
-
-## Constraints
-
- **Single dialect.** The agent translates its protocol into this JSON; the model does not learn
-  vendor protocols. Extending the model with a new unit kind or field means extending the dialect.
- **Agent-produced counts.** Toolhead, AMS, and slot counts come from the device payload. Nothing
-  caps them at two toolheads or four slots except the Bambu contract described above.
- **Extruder dialect invariants.** `device.extruder.state`'s count field must equal the length of
-  `info[]`, and `info[]` must be ordered by extruder id with `id` equal to the array index: the
-  parser places toolheads by array position while `GetExtderById()` indexes by id.
- **One filament road per toolhead.** Each toolhead renders a single AMS filament road rather than an
-  independent per-toolhead road state. A generic scaffold that allowed the latter was removed as
-  unused; the one-extruder-per-toolhead road is the intended model.
- **Preset/device agreement.** The generic layout and virtual-slot range derive their count from the
-  selected printer preset. A printer preset must therefore declare the same number of
-  `nozzle_diameter` entries as the device has toolheads. A mismatch is surfaced only as a log warning
-  (`StatusPanel::check_extruder_count_mismatch()`), deliberately log-only, because the sidebar and
-  extruder logic would otherwise silently disagree.
- **Bambu compatibility.** Bambu-specific presentation (left/right pair, fixed 4-slot units, fixed
-  virtual ids, physical/logical inversion) is preserved behind the vendor check. Generic paths do
-  not alter it.
- **Tray-index invariant.** The generic tray-index map is cumulative, so payload tray ids must be
-  unique, 0-based, and contiguous per unit. A malformed id is a producer error.
- **Protocol markers.** The dialect has no neutral equivalent for some Bambu state, so agents that
-  lack it send empty `print.cfg`, `print.fun`, `print.aux`, and `print.stat`. Their presence selects
-  the new-protocol parse path; they are compatibility markers, not feature switches.
-
-## Main implementation locations
-
- [`DevExtruderSystem`](../../src/slic3r/GUI/DeviceCore/DevExtruderSystem.h) — toolhead model and the
-  `device.extruder` parser
- [`DevFilaSystem`](../../src/slic3r/GUI/DeviceCore/DevFilaSystem.h) — AMS/tray model, the AMS parser,
-  and the mapping helpers
- [`DevDefs.h`](../../src/slic3r/GUI/DeviceCore/DevDefs.h) — `DevAmsType`, extruder ids, and virtual
-  tray ids
- [`DeviceManager.cpp`](../../src/slic3r/GUI/DeviceManager.cpp) — message dispatch, `vir_slot`
-  parsing, and device state assembly
- [`AMSControl.cpp`](../../src/slic3r/GUI/Widgets/AMSControl.cpp) — per-toolhead AMS panes
-  (`CreateAmsMultiNozzle`) and the generic layout
- [`AMSItem.hpp`](../../src/slic3r/GUI/Widgets/AMSItem.hpp) — `AMSModel` and the variable-lane AMS
-  rendering
- [`StatusPanel.cpp`](../../src/slic3r/GUI/StatusPanel.cpp) — `ExtruderImage`, the toolhead selector,
-  and per-toolhead temperature controls
- [`MoonrakerPrinterAgent.cpp`](../../src/slic3r/Utils/MoonrakerPrinterAgent.cpp) — producer example
-  (AMS payload and the `device.extruder` encoding)
@@ -592,6 +592,10 @@
 			"name": "SUNLU PETG @base",
 			"sub_path": "filament/SUNLU/SUNLU PETG @base.json"
 		},
+		{
+			"name": "School House Spools PETG @base",
+			"sub_path": "filament/SchoolHouseSpools/School House Spools PETG @base.json"
+		},
 		{
 			"name": "eSUN PETG @base",
 			"sub_path": "filament/eSUN/eSUN PETG @base.json"
@@ -1096,6 +1100,10 @@
 			"name": "SUNLU Wood PLA @base",
 			"sub_path": "filament/SUNLU/SUNLU Wood PLA @base.json"
 		},
+		{
+			"name": "School House Spools PLA @base",
+			"sub_path": "filament/SchoolHouseSpools/School House Spools PLA @base.json"
+		},
 		{
 			"name": "Valment PLA @base",
 			"sub_path": "filament/Valment/Valment PLA @base.json"
@@ -2260,6 +2268,10 @@
 			"name": "SUNLU PETG @System",
 			"sub_path": "filament/SUNLU/SUNLU PETG @System.json"
 		},
+		{
+			"name": "School House Spools PETG @System",
+			"sub_path": "filament/SchoolHouseSpools/School House Spools PETG @System.json"
+		},
 		{
 			"name": "eSUN PETG @System",
 			"sub_path": "filament/eSUN/eSUN PETG @System.json"
@@ -3812,6 +3824,10 @@
 			"name": "SUNLU Wood PLA @System",
 			"sub_path": "filament/SUNLU/SUNLU Wood PLA @System.json"
 		},
+		{
+			"name": "School House Spools PLA @System",
+			"sub_path": "filament/SchoolHouseSpools/School House Spools PLA @System.json"
+		},
 		{
 			"name": "Valment PLA @System",
 			"sub_path": "filament/Valment/Valment PLA @System.json"
@@ -0,0 +1,18 @@
+{
+	"type": "filament",
+	"name": "School House Spools PETG @System",
+	"inherits": "School House Spools PETG @base",
+	"from": "system",
+	"setting_id": "RSu2orfhR8ktT36h",
+	"instantiation": "true",
+	"filament_max_volumetric_speed": [
+		"13"
+	],
+	"filament_long_retractions_when_cut": [
+		"1"
+	],
+	"filament_retraction_distances_when_cut": [
+		"18"
+	],
+	"compatible_printers": []
+}
@@ -0,0 +1,80 @@
+{
+	"type": "filament",
+	"name": "School House Spools PETG @base",
+	"inherits": "fdm_filament_pet",
+	"from": "system",
+	"filament_id": "OFnaCGQ9",
+	"instantiation": "false",
+	"cool_plate_temp": [
+		"0"
+	],
+	"cool_plate_temp_initial_layer": [
+		"0"
+	],
+	"eng_plate_temp": [
+		"70"
+	],
+	"eng_plate_temp_initial_layer": [
+		"70"
+	],
+	"fan_cooling_layer_time": [
+		"30"
+	],
+	"fan_max_speed": [
+		"40"
+	],
+	"fan_min_speed": [
+		"10"
+	],
+	"filament_cost": [
+		"16.00"
+	],
+	"filament_density": [
+		"1.25"
+	],
+	"filament_flow_ratio": [
+		"0.95"
+	],
+	"filament_max_volumetric_speed": [
+		"8"
+	],
+	"filament_multitool_ramming_flow": [
+		"8"
+	],
+	"filament_vendor": [
+		"School House Spools"
+	],
+	"hot_plate_temp": [
+		"70"
+	],
+	"hot_plate_temp_initial_layer": [
+		"70"
+	],
+	"nozzle_temperature": [
+		"252"
+	],
+	"nozzle_temperature_initial_layer": [
+		"252"
+	],
+	"nozzle_temperature_range_high": [
+		"270"
+	],
+	"nozzle_temperature_range_low": [
+		"230"
+	],
+	"overhang_fan_speed": [
+		"90"
+	],
+	"overhang_fan_threshold": [
+		"10%"
+	],
+	"slow_down_layer_time": [
+		"12"
+	],
+	"textured_plate_temp": [
+		"70"
+	],
+	"textured_plate_temp_initial_layer": [
+		"70"
+	]
+}
@@ -0,0 +1,18 @@
+{
+	"type": "filament",
+	"name": "School House Spools PLA @System",
+	"inherits": "School House Spools PLA @base",
+	"from": "system",
+	"setting_id": "3rHJk6SVAvFzyHI0",
+	"instantiation": "true",
+	"filament_max_volumetric_speed": [
+		"21"
+	],
+	"filament_long_retractions_when_cut": [
+		"1"
+	],
+	"filament_retraction_distances_when_cut": [
+		"18"
+	],
+	"compatible_printers": []
+}
@@ -0,0 +1,35 @@
+{
+	"type": "filament",
+	"name": "School House Spools PLA @base",
+	"inherits": "fdm_filament_pla",
+	"from": "system",
+	"filament_id": "OFHzwmT9",
+	"instantiation": "false",
+	"filament_cost": [
+		"17.00"
+	],
+	"filament_density": [
+		"1.26"
+	],
+	"filament_flow_ratio": [
+		"0.98"
+	],
+	"filament_max_volumetric_speed": [
+		"12"
+	],
+	"filament_vendor": [
+		"School House Spools"
+	],
+	"filament_scarf_seam_type": [
+		"none"
+	],
+	"filament_scarf_height": [
+		"10%"
+	],
+	"filament_scarf_gap": [
+		"0%"
+	],
+	"filament_scarf_length": [
+		"10"
+	]
+}
@@ -1,6 +1,6 @@
 {
 	"name": "RatRig",
-	"version": "02.04.00.06",
+	"version": "02.04.00.07",
 	"force_update": "0",
 	"description": "RatRig configurations",
 	"machine_model_list": [
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -107,7 +107,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -107,7 +107,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -107,7 +107,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -131,7 +131,7 @@
 	"bed_exclude_area": [
 		"0x0"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single]",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single]",
 	"machine_end_gcode": "END_PRINT",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n",
@@ -4607,16 +4607,6 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
                        maps.erase(j);
                    }
                }
-            }
-            if (is_placeholder) {
-                // Orca: an empty AMS slot is a placeholder, not a filament - never synthesize a
-                // preset for it. Kept here only to keep index alignment with ams_infos; the sync
-                // drops it so no filament slot is created or retained for an empty tray.
-                ams_filament_presets.push_back("");
-                ams_filament_colors.push_back("");
-                ams_filament_color_types.push_back("");
-                ams_multi_color_filment.push_back({});
-            } else if (use_map) {
                ams_filament_presets.push_back("Generic PLA");//for unknow matieral
                auto default_unknown_color = "#CECECE";
                ams_filament_colors.push_back(default_unknown_color);
@@ -4625,6 +4615,12 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
                    filament_multi_color.push_back(default_unknown_color);
                }
                ams_multi_color_filment.push_back(filament_multi_color);
+            } else if (is_placeholder) {
+                // Orca: push placeholders to keep index alignment with ams_infos
+                ams_filament_presets.push_back("");
+                ams_filament_colors.push_back("");
+                ams_filament_color_types.push_back("");
+                ams_multi_color_filment.push_back({});
            }
            continue;
        }
@@ -4988,10 +4984,6 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
                    result_multi_colors.push_back(
                        i < ams_multi_color_filment.size() ? ams_multi_color_filment[i]
                                                           : std::vector<std::string>{ams_filament_colors[i]});
-                } else if (i < ams_infos.size() && ams_infos[i].is_placeholder) {
-                    // Orca: an empty AMS slot is a placeholder, not a filament, so drop it instead of
-                    // keeping or filling a slot for it. The device AMS panel still shows the empty tray.
-                    continue;
                } else if (i < exist_presets.size()) {
                    // Empty tray or beyond tray count: keep existing filament
                    result_colors.push_back(exist_colors[i]);
@@ -5016,8 +5008,8 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
            filament_color_type->values = result_color_types;
            this->filament_presets      = result_presets;
            ams_multi_color_filment     = result_multi_colors;
-            filament_map->values.resize(result_presets.size(), 1);
-            filament_volume_map->values.resize(result_presets.size(), static_cast<int>(NozzleVolumeType::nvtStandard));
+            filament_map->values.resize(total, 1);
+            filament_volume_map->values.resize(total, static_cast<int>(NozzleVolumeType::nvtStandard));
        } else {
            // BBL: existing wholesale replace
            filament_color->values = ams_filament_colors;
@@ -858,11 +858,10 @@ void PrintObject::contour_z()
    BOOST_LOG_TRIVIAL(debug) << "Contouring in parallel - start";

    TriangleMesh mesh = this->m_model_object->raw_mesh();
-    if (m_model_object->instances.size() != 1) {
-        throw RuntimeError("ContourZ: unexpected number of instances");
-    }
-
-    ModelInstance *inst = m_model_object->instances.front();
+    // A PrintObject groups the instances that share their whole transformation but the XY shift: an
+    // instance rotated, scaled or mirrored differently is a PrintObject of its own. So the first
+    // instance stands for all of them.
+    const ModelInstance *inst = m_instances.front().model_instance;
    Point                    center_offset = this->center_offset();
    Geometry::Transformation trans = inst->get_transformation();

@@ -85,6 +85,96 @@ static std::string float_to_string_with_precision(float value, int precision = 3
    return stream.str();
 }

+static std::string colour_to_ams_string(const wxColour& color)
+{
+    char col_buf[10];
+    sprintf(col_buf, "%02X%02X%02X%02X", (int)color.Red(), (int)color.Green(), (int)color.Blue(), (int)color.Alpha());
+    return col_buf;
+}
+
+static wxColour mix_colour(const wxColour& left, const wxColour& right, double ratio)
+{
+    ratio = std::max(0.0, std::min(1.0, ratio));
+    auto mix_channel = [ratio](unsigned char l, unsigned char r) {
+        return static_cast<unsigned char>(std::round(l + (r - l) * ratio));
+    };
+    return wxColour(mix_channel(left.Red(), right.Red()),
+                    mix_channel(left.Green(), right.Green()),
+                    mix_channel(left.Blue(), right.Blue()),
+                    mix_channel(left.Alpha(), right.Alpha()));
+}
+
+static std::vector<ColorPickerPopup::ColorItem> collect_ams_color_items(DevFilaSystem* fila_system)
+{
+    std::vector<ColorPickerPopup::ColorItem> items;
+    if (!fila_system) return items;
+
+    for (const auto& ams_pair : fila_system->GetAmsList()) {
+        DevAms* ams = ams_pair.second;
+        if (!ams) continue;
+
+        for (const auto& tray_pair : ams->GetTrays()) {
+            DevAmsTray* tray = tray_pair.second;
+            if (!tray || !tray->is_tray_info_ready()) continue;
+
+            ColorPickerPopup::ColorItem item;
+            for (const std::string& col : tray->cols) {
+                item.colors.emplace_back(DevAmsTray::decode_color(col));
+            }
+            if (item.colors.empty() && !tray->color.empty()) {
+                item.colors.emplace_back(DevAmsTray::decode_color(tray->color));
+            }
+            if (item.colors.empty()) continue;
+
+            item.ctype = item.colors.size() > 1 ? tray->ctype : 2;
+            items.emplace_back(std::move(item));
+        }
+    }
+
+    return items;
+}
+
+static std::vector<ColorPickerPopup::ColorItem> collect_preset_color_items(const std::string& filament_id)
+{
+    std::vector<ColorPickerPopup::ColorItem> items;
+    if (filament_id.empty()) return items;
+
+    auto* clr_query = GUI::wxGetApp().get_filament_color_code_query();
+    if (!clr_query) return items;
+
+    auto* agent = wxGetApp().getAgent();
+    const std::string catalog_id = agent ? agent->from_orca_filament_id(filament_id) : filament_id;
+    FilamentColorCodes* color_codes = clr_query->GetFilaInfoMap(wxString::FromUTF8(catalog_id));
+    if (!color_codes || !color_codes->GetFilamentColor2CodeMap()) return items;
+
+    std::set<std::string> seen;
+    for (const auto& color_pair : *color_codes->GetFilamentColor2CodeMap()) {
+        const FilamentColor& fila_color = color_pair.first;
+        FilamentColorCode* color_code = color_pair.second;
+        if (!color_code || fila_color.GetColors().empty()) continue;
+
+        ColorPickerPopup::ColorItem item;
+        item.ctype = fila_color.ColorCount() < 2 ? 2 :
+            (fila_color.m_color_type == FilamentColor::ColorType::GRADIENT_CLR ? 0 : 1);
+        item.name = color_code->GetFilaColorName();
+
+        std::string key = std::to_string(item.ctype);
+        for (const wxColour& color : fila_color.GetColors()) {
+            item.colors.emplace_back(color);
+            char rgba[9];
+            std::snprintf(rgba, sizeof(rgba), "%02X%02X%02X%02X",
+                static_cast<unsigned>(color.Red()), static_cast<unsigned>(color.Green()),
+                static_cast<unsigned>(color.Blue()), static_cast<unsigned>(color.Alpha()));
+            key += "|" + std::string(rgba);
+        }
+
+        if (item.colors.empty() || !seen.insert(key).second) continue;
+        items.emplace_back(std::move(item));
+    }
+
+    return items;
+}
+
 AMSMaterialsSetting::AMSMaterialsSetting(wxWindow *parent, wxWindowID id)
    : DPIDialog(parent, id, _L("AMS Materials Setting"), wxDefaultPosition, wxDefaultSize, wxCAPTION | wxCLOSE_BOX)
    , m_color_picker_popup(ColorPickerPopup(this))
@@ -740,8 +830,19 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event)
    nozzle_temp_min.ToLong(&nozzle_temp_min_int);
    nozzle_temp_max.ToLong(&nozzle_temp_max_int);
    wxColour color = m_clr_picker->m_colour;
-    char col_buf[10];
-    sprintf(col_buf, "%02X%02X%02X%02X", (int)color.Red(), (int)color.Green(), (int)color.Blue(), (int)color.Alpha());
+    std::string tray_color = colour_to_ams_string(color);
+    std::vector<std::string> tray_colors;
+    int tray_ctype = 2;
+    // Only firmware advertising fun2[23] receives the manual multi-color fields.
+    if (obj->is_support_filament_manual_multi_color) {
+        for (const wxColour& selected_color : m_clr_picker->m_cols) {
+            tray_colors.emplace_back(colour_to_ams_string(selected_color));
+        }
+        if (tray_colors.empty()) {
+            tray_colors.emplace_back(tray_color);
+        }
+        tray_ctype = tray_colors.size() > 1 ? m_clr_picker->ctype : 2;
+    }

    if (ams_filament_id.empty() || nozzle_temp_min.empty() || nozzle_temp_max.empty() || m_filament_type.empty()) {
        BOOST_LOG_TRIVIAL(trace) << "Invalid Setting id";
@@ -760,13 +861,33 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event)
                            << ", tray_info_idx (filament_id) = " << ams_filament_id
                            << ", setting_id = " << ams_setting_id
                            << ", tray_type = " << m_filament_type
-                            << ", tray_color = " << col_buf
+                            << ", tray_color = " << tray_color
                            << ", nozzle_temp_min = " << nozzle_temp_min_int
                            << ", nozzle_temp_max = " << nozzle_temp_max_int;

    // set filament
    if (m_is_third) {
-        obj->command_ams_filament_settings(ams_id, slot_id, ams_filament_id, ams_setting_id, std::string(col_buf), m_filament_type, nozzle_temp_min_int, nozzle_temp_max_int);
+        obj->command_ams_filament_settings(ams_id, slot_id, ams_filament_id, ams_setting_id, tray_color, m_filament_type, nozzle_temp_min_int, nozzle_temp_max_int,
+                                           tray_colors, tray_ctype);
+
+        // Refresh the edited tray immediately while its MQTT acknowledgement is pending.
+        DevAmsTray* tray = nullptr;
+        if (is_virtual_tray()) {
+            for (auto& virtual_tray : obj->vt_slot) {
+                if (virtual_tray.id == std::to_string(ams_id)) {
+                    tray = &virtual_tray;
+                    break;
+                }
+            }
+        } else {
+            tray = obj->GetFilaSystem()->GetAmsTray(std::to_string(ams_id), std::to_string(slot_id));
+        }
+        if (tray) {
+            tray->color = tray_color;
+            tray->cols = tray_colors;
+            tray->ctype = tray_ctype;
+            tray->set_hold_count();
+        }
    }

    //reset param
@@ -923,8 +1044,15 @@ void AMSMaterialsSetting::set_ctype(int ctype)

 void AMSMaterialsSetting::on_picker_color(wxCommandEvent& event)
 {
-    unsigned int color_num  = event.GetInt();
-    set_color(wxColour(color_num>>24&0xFF, color_num>>16&0xFF, color_num>>8&0xFF, color_num&0xFF));
+    std::vector<wxColour> colors = m_color_picker_popup.get_selected_colours();
+    if (colors.empty()) {
+        unsigned int color_num = event.GetInt();
+        colors.emplace_back(color_num >> 24 & 0xFF, color_num >> 16 & 0xFF, color_num >> 8 & 0xFF, color_num & 0xFF);
+    }
+
+    set_ctype(m_color_picker_popup.get_selected_ctype());
+    set_color(colors.front());
+    set_colors(colors);
 }

 void AMSMaterialsSetting::on_clr_picker(wxMouseEvent &event)
@@ -939,14 +1067,12 @@ void AMSMaterialsSetting::on_clr_picker(wxMouseEvent &event)
        }
    }

-    std::vector<wxColour> ams_colors;
-    obj->GetFilaSystem()->CollectAmsColors(ams_colors);
-
+    m_color_picker_popup.set_ams_colours(collect_ams_color_items(obj->GetFilaSystem().get()));
+    m_color_picker_popup.set_preset_colours(collect_preset_color_items(ams_filament_id));
+    m_color_picker_popup.set_def_colour(m_clr_picker->m_colour, m_clr_picker->m_cols, m_clr_picker->ctype);
    wxPoint img_pos = m_clr_picker->ClientToScreen(wxPoint(0, 0));
    wxPoint popup_pos(img_pos.x - m_color_picker_popup.GetSize().x - FromDIP(95), img_pos.y - FromDIP(65));
    m_color_picker_popup.Position(popup_pos, wxSize(0, 0));
-    m_color_picker_popup.set_ams_colours(ams_colors);
-    m_color_picker_popup.set_def_colour(m_clr_picker->m_colour);
    m_color_picker_popup.Popup();
 }

@@ -1735,7 +1861,46 @@ void ColorPicker::doRender(wxDC& dc)
    auto radius = m_show_full ? size.x / 2 - FromDIP(1) : size.x / 2;
    if (m_selected) radius -= FromDIP(1);

-    if (alpha == 0) {
+    if (m_show_full && m_cols.size() > 1) {
+        if (ctype == 0) {
+            const double center_x = size.x / 2.0;
+            const double center_y = size.y / 2.0;
+            const double draw_radius = radius;
+            dc.SetPen(*wxTRANSPARENT_PEN);
+            for (int x = 0; x < size.x; ++x) {
+                const double dx = x + 0.5 - center_x;
+                if (std::abs(dx) > draw_radius) continue;
+
+                const double half_height = std::sqrt(std::max(0.0, draw_radius * draw_radius - dx * dx));
+                const int top = std::max(0, static_cast<int>(std::ceil(center_y - half_height)));
+                const int bottom = std::min(size.y - 1, static_cast<int>(std::floor(center_y + half_height)));
+                const double pos = size.x > 1 ? static_cast<double>(x) / (size.x - 1) : 0.0;
+                const double scaled = pos * (m_cols.size() - 1);
+                const size_t idx = std::min(static_cast<size_t>(scaled), m_cols.size() - 2);
+                const double ratio = scaled - idx;
+
+                if (top <= bottom) {
+                    dc.SetBrush(wxBrush(mix_colour(m_cols[idx], m_cols[idx + 1], ratio)));
+                    dc.DrawRectangle(x, top, 1, bottom - top + 1);
+                }
+            }
+        }
+        else {
+            float ev_angle = 360.0 / m_cols.size();
+            const float overlap = 2.0f;
+            wxPoint center(size.x / 2, size.y / 2);
+            dc.SetPen(*wxTRANSPARENT_PEN);
+            dc.SetBrush(wxBrush(m_cols.front()));
+            dc.DrawCircle(center.x, center.y, radius);
+            for (int i = 0; i < m_cols.size(); i++) {
+                dc.SetBrush(m_cols[i]);
+                float startAngle = 270.0f + i * ev_angle;
+                float endAngle = startAngle + ev_angle;
+                dc.DrawEllipticArc(center.x - radius, center.y - radius, 2 * radius, 2 * radius, startAngle - overlap, endAngle + overlap);
+            }
+        }
+    }
+    else if (alpha == 0) {
        wxSize bmp_size = m_bitmap_transparent_def.GetBmpSize();
        int center_x = (size.x - bmp_size.x) / 2;
        int center_y = (size.y - bmp_size.y) / 2;
@@ -1777,52 +1942,6 @@ void ColorPicker::doRender(wxDC& dc)
        dc.SetPen(wxPen(wxColour("#6B6B6B")));
        dc.SetBrush(*wxTRANSPARENT_BRUSH);
        dc.DrawCircle(size.x / 2, size.y / 2, radius);
-
-        if (m_cols.size() > 1) {
-            if (ctype == 0) {
-                int left = FromDIP(0);
-                float total_width = size.x;
-                int gwidth = std::round(total_width / (m_cols.size() - 1));
-
-                for (int i = 0; i < m_cols.size() - 1; i++) {
-
-                    if ((left + gwidth) > (size.x)) {
-                        gwidth = size.x - left;
-                    }
-
-                    auto rect = wxRect(left, 0, gwidth, size.y);
-                    dc.GradientFillLinear(rect, m_cols[i], m_cols[i + 1], wxEAST);
-                    left += gwidth;
-                }
-                if (wxGetApp().dark_mode()) {
-                    dc.DrawBitmap(m_bitmap_border_dark, wxPoint(0, 0));
-                }
-                else {
-                    dc.DrawBitmap(m_bitmap_border, wxPoint(0, 0));
-                }
-            }
-            else {
-                float ev_angle = 360.0 / m_cols.size();
-                float startAngle = 270.0;
-                float endAngle = 270.0;
-                dc.SetPen(*wxTRANSPARENT_PEN);
-                for (int i = 0; i < m_cols.size(); i++) {
-                    dc.SetBrush(m_cols[i]);
-                    endAngle += ev_angle;
-                    endAngle = endAngle > 360.0 ? endAngle - 360.0 : endAngle;
-                    wxPoint center(size.x / 2, size.y / 2);
-                    dc.DrawEllipticArc(center.x - radius, center.y - radius, 2 * radius, 2 * radius, startAngle, endAngle);
-                    startAngle += ev_angle;
-                    startAngle = startAngle > 360.0 ? startAngle - 360.0 : startAngle;
-                }
-                if (wxGetApp().dark_mode()) {
-                    dc.DrawBitmap(m_bitmap_border_dark, wxPoint(0, 0));
-                }
-                else {
-                    dc.DrawBitmap(m_bitmap_border, wxPoint(0, 0));
-                }
-            }
-        }
    }

    if (m_is_empty) {
@@ -1891,19 +2010,21 @@ ColorPickerPopup::ColorPickerPopup(wxWindow* parent)
    m_ams_fg_sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);

    //other
-    wxFlexGridSizer* fg_sizer;
-    fg_sizer = new wxFlexGridSizer(0, 8, 0, 0);
-    fg_sizer->SetFlexibleDirection(wxBOTH);
-    fg_sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
+    m_other_fg_sizer = new wxFlexGridSizer(0, 8, 0, 0);
+    m_other_fg_sizer->SetFlexibleDirection(wxBOTH);
+    m_other_fg_sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);


    for (wxColour col : m_def_colors) {
        auto cp = new ColorPicker(m_def_color_box, wxID_ANY, wxDefaultPosition, wxDefaultSize);
        cp->set_color(col);
+        cp->set_colors({col});
+        cp->ctype = 2;
        cp->set_selected(false);
        cp->SetBackgroundColour(StateColor::darkModeColorFor(wxColour(238,238,238)));
        m_color_pickers.push_back(cp);
-        fg_sizer->Add(cp, 0, wxALL, FromDIP(3));
+        m_default_color_pickers.push_back(cp);
+        m_other_fg_sizer->Add(cp, 0, wxALL, FromDIP(3));
        cp->Bind(wxEVT_LEFT_DOWN, [this, cp](auto& e) {
            set_def_colour(cp->m_colour);

@@ -1970,7 +2091,7 @@ ColorPickerPopup::ColorPickerPopup(wxWindow* parent)
    m_sizer_box->Add(m_sizer_ams, 1, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(10));
    m_sizer_box->Add(m_ams_fg_sizer, 0, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(10));
    m_sizer_box->Add(m_sizer_other, 1, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(10));
-    m_sizer_box->Add(fg_sizer, 0, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(10));
+    m_sizer_box->Add(m_other_fg_sizer, 0, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(10));
    m_sizer_box->Add(m_sizer_custom, 0, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(10));
    m_sizer_box->Add(m_custom_cp, 0, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(16));
    m_sizer_box->Add(0, 0, 0, wxTOP, FromDIP(10));
@@ -1981,7 +2102,7 @@ ColorPickerPopup::ColorPickerPopup(wxWindow* parent)
    m_def_color_box->Fit();

    m_sizer_main->Add(m_def_color_box, 0, wxALL | wxEXPAND, 10);
-    SetSizer(m_sizer_main);
+    SetSizerAndFit(m_sizer_main);
    Layout();
    Fit();

@@ -2019,13 +2140,15 @@ void ColorPickerPopup::on_custom_clr_picker(wxMouseEvent& /*event*/)
    wxPostEvent(GetParent(), evt);
 }

-void ColorPickerPopup::set_ams_colours(std::vector<wxColour> ams)
+void ColorPickerPopup::set_ams_colours(const std::vector<ColorItem>& ams)
 {
+    m_ams_fg_sizer->Clear(false);
    if (m_ams_color_pickers.size() > 0) {
        for (ColorPicker* col_pick:m_ams_color_pickers) {

            std::vector<ColorPicker*>::iterator iter = find(m_color_pickers.begin(), m_color_pickers.end(), col_pick);
            if (iter != m_color_pickers.end()) {
+                col_pick->Hide();
                col_pick->Destroy();
                m_color_pickers.erase(iter);
            }
@@ -2035,17 +2158,22 @@ void ColorPickerPopup::set_ams_colours(std::vector<wxColour> ams)
    }


-    m_ams_colors = ams;
-    for (wxColour col : m_ams_colors) {
+    m_ams_color_items = ams;
+    for (const ColorItem& item : m_ams_color_items) {
+        if (item.colors.empty()) continue;
+
        auto cp = new ColorPicker(m_def_color_box, wxID_ANY, wxDefaultPosition, wxDefaultSize);
-        cp->set_color(col);
+        cp->set_color(item.colors.front());
+        cp->set_colors(item.colors);
+        cp->ctype = item.colors.size() > 1 ? item.ctype : 2;
+        cp->set_show_full(true);
        cp->set_selected(false);
        cp->SetBackgroundColour(StateColor::darkModeColorFor(wxColour(238,238,238)));
        m_color_pickers.push_back(cp);
        m_ams_color_pickers.push_back(cp);
        m_ams_fg_sizer->Add(cp, 0, wxALL, FromDIP(3));
        cp->Bind(wxEVT_LEFT_DOWN, [this, cp](auto& e) {
-            set_def_colour(cp->m_colour);
+            set_def_colour(cp->m_colour, cp->m_cols, cp->ctype);

            wxCommandEvent evt(EVT_SELECTED_COLOR);
            unsigned long g_col = ((cp->m_colour.Red() & 0xff) << 24) + ((cp->m_colour.Green() & 0xff) << 16) + ((cp->m_colour.Blue() & 0xff) << 8) + (cp->m_colour.Alpha() & 0xff);
@@ -2058,9 +2186,68 @@ void ColorPickerPopup::set_ams_colours(std::vector<wxColour> ams)
    Fit();
 }

-void ColorPickerPopup::set_def_colour(wxColour col)
+void ColorPickerPopup::set_preset_colours(const std::vector<ColorItem>& preset_colors)
+{
+    m_other_fg_sizer->Clear(false);
+    if (!m_preset_color_pickers.empty()) {
+        for (ColorPicker* col_pick : m_preset_color_pickers) {
+            auto iter = std::find(m_color_pickers.begin(), m_color_pickers.end(), col_pick);
+            if (iter != m_color_pickers.end()) {
+                col_pick->Hide();
+                col_pick->Destroy();
+                m_color_pickers.erase(iter);
+            }
+        }
+        m_preset_color_pickers.clear();
+    }
+
+    for (const ColorItem& item : preset_colors) {
+        if (item.colors.empty()) continue;
+
+        auto cp = new ColorPicker(m_def_color_box, wxID_ANY, wxDefaultPosition, wxDefaultSize);
+        cp->set_color(item.colors.front());
+        cp->set_colors(item.colors);
+        cp->ctype = item.colors.size() > 1 ? item.ctype : 2;
+        cp->set_show_full(true);
+        cp->set_selected(false);
+        cp->SetBackgroundColour(StateColor::darkModeColorFor(wxColour(238,238,238)));
+        if (!item.name.empty()) {
+            cp->SetToolTip(item.name);
+        }
+
+        m_color_pickers.push_back(cp);
+        m_preset_color_pickers.push_back(cp);
+        cp->Bind(wxEVT_LEFT_DOWN, [this, cp](auto& e) {
+            set_def_colour(cp->m_colour, cp->m_cols, cp->ctype);
+
+            wxCommandEvent evt(EVT_SELECTED_COLOR);
+            unsigned long g_col = ((cp->m_colour.Red() & 0xff) << 24) + ((cp->m_colour.Green() & 0xff) << 16) + ((cp->m_colour.Blue() & 0xff) << 8) + (cp->m_colour.Alpha() & 0xff);
+            evt.SetInt(g_col);
+            wxPostEvent(GetParent(), evt);
+        });
+    }
+
+    const bool show_default_colours = m_preset_color_pickers.empty();
+    for (ColorPicker* cp : m_default_color_pickers) {
+        cp->Show(show_default_colours);
+    }
+    for (ColorPicker* cp : (show_default_colours ? m_default_color_pickers : m_preset_color_pickers)) {
+        m_other_fg_sizer->Add(cp, 0, wxALL, FromDIP(3));
+    }
+
+    m_other_fg_sizer->Layout();
+    Layout();
+    Fit();
+}
+
+void ColorPickerPopup::set_def_colour(wxColour col, std::vector<wxColour> cols, int ctype)
 {
    m_def_col = col;
+    if (cols.empty()) {
+        cols.push_back(col);
+    }
+    m_def_cols = cols;
+    m_def_ctype = m_def_cols.size() > 1 ? ctype : 2;

    for (ColorPicker* cp : m_color_pickers) {
        if (cp->m_selected) {
@@ -2069,7 +2256,8 @@ void ColorPickerPopup::set_def_colour(wxColour col)
    }

    for (ColorPicker* cp : m_color_pickers) {
-        if (cp->m_colour == m_def_col) {
+        if (!cp->IsShown()) continue;
+        if (cp->ctype == m_def_ctype && cp->m_cols == m_def_cols) {
            cp->set_selected(true);
            break;
        }
@@ -82,14 +82,22 @@ public:
 class ColorPickerPopup : public PopupWindow
 {
 public:
+    struct ColorItem
+    {
+        std::vector<wxColour> colors;
+        int                   ctype = 2;
+        wxString              name;
+    };
+
    ScalableBitmap m_ts_bitmap_custom;
    wxStaticBitmap* m_ts_stbitmap_custom;
    StaticBox* m_custom_cp;
    StaticBox* m_def_color_box;
    wxFlexGridSizer* m_ams_fg_sizer;
+    wxFlexGridSizer* m_other_fg_sizer;
    wxColour m_def_col;
    std::vector<wxColour> m_def_colors;
-    std::vector<wxColour> m_ams_colors;
+    std::vector<ColorItem> m_ams_color_items;
    std::vector<ColorPicker*> m_color_pickers;
    std::vector<ColorPicker*> m_ams_color_pickers;

@@ -97,13 +105,20 @@ public:
    ColorPickerPopup(wxWindow* parent);
    ~ColorPickerPopup() {};
    void on_custom_clr_picker(wxMouseEvent& event);
-    void set_ams_colours(std::vector<wxColour> ams);
-    void set_def_colour(wxColour col);
+    void set_ams_colours(const std::vector<ColorItem>& ams);
+    void set_preset_colours(const std::vector<ColorItem>& preset_colors);
+    void set_def_colour(wxColour col, std::vector<wxColour> cols = {}, int ctype = 2);
+    const std::vector<wxColour>& get_selected_colours() const { return m_def_cols; }
+    int get_selected_ctype() const { return m_def_ctype; }
    void paintEvent(wxPaintEvent& evt);
    virtual void OnDismiss() wxOVERRIDE;
    virtual bool ProcessLeftDown(wxMouseEvent& event) wxOVERRIDE;

-public:
+private:
+    std::vector<ColorPicker*> m_default_color_pickers;
+    std::vector<ColorPicker*> m_preset_color_pickers;
+    std::vector<wxColour> m_def_cols;
+    int m_def_ctype = 2;
 };


@@ -747,7 +747,9 @@ Print::ApplyStatus BackgroundSlicingProcess::apply(const Model& model, const Dyn

    // Orca: prevent resetting under gcode viewer mode
    if (invalidated != PrintBase::APPLY_STATUS_UNCHANGED) {
-        const auto plater = GUI::wxGetApp().mainframe->m_plater;
+        // Use the app’s plater accessor instead of going through mainframe, otherwise anything during startup that reaches apply() 
+        // (loading presets, config or input files, e.g. from the CLI) therefore dereferences a null `mainframe` and crashes.
+        const auto plater = GUI::wxGetApp().plater();
        if (plater && plater->only_gcode_mode()) {
            invalidated = PrintBase::APPLY_STATUS_UNCHANGED;
        }
@@ -163,8 +163,8 @@ public:
    ~devPrinterUtil() = delete;

 public:
-    static bool IsVirtualSlot(int ams_id);
-    static bool IsVirtualSlot(const std::string& ams_id);
+    static bool IsVirtualSlot(int ams_id) { return (ams_id == VIRTUAL_TRAY_MAIN_ID || ams_id == VIRTUAL_TRAY_DEPUTY_ID);}
+    static bool IsVirtualSlot(const std::string& ams_id) { return (ams_id == VIRTUAL_AMS_MAIN_ID_STR || ams_id == VIRTUAL_AMS_DEPUTY_ID_STR); }
 };

 namespace GUI
@@ -198,6 +198,3 @@ template<> struct std::hash<NozzleDef>
        return h1 ^ (h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
    };
 };
-
-// key(extruder_id) -> { key1(nozzle type info), val1( number of the nozzle type)}
-using ExtruderNozzleInfos = std::unordered_map<int, std::unordered_map<NozzleDef, int>>;
@@ -8,7 +8,6 @@
 #include <cstdlib>
 #include <chrono>
 #include <nlohmann/json.hpp>
-#include <wx/app.h>
 #include <wx/colour.h>
 #include <string>
 #include <wx/string.h>
@@ -34,36 +33,6 @@
 using namespace nlohmann;

 namespace Slic3r {
-
-bool devPrinterUtil::IsVirtualSlot(int ams_id)
-{
-    // When the app or preset bundle is unavailable we cannot know the vendor's
-    // extruder count, so fall back deterministically to the fixed Bambu pair
-    // {255, 254} rather than guessing from an unknown generic layout.
-    if (wxTheApp == nullptr || GUI::wxGetApp().preset_bundle == nullptr || GUI::wxGetApp().preset_bundle->is_bbl_vendor())
-        return ams_id == VIRTUAL_TRAY_MAIN_ID || ams_id == VIRTUAL_TRAY_DEPUTY_ID;
-
-    const int extruder_count = GUI::wxGetApp().preset_bundle->get_printer_extruder_count();
-    return ams_id >= VIRTUAL_TRAY_MAIN_ID - extruder_count + 1 && ams_id <= VIRTUAL_TRAY_MAIN_ID;
-}
-
-bool devPrinterUtil::IsVirtualSlot(const std::string& ams_id)
-{
-    // Strict: only a fully numeric string is a valid slot id. std::stoi alone
-    // would accept trailing garbage (e.g. "255abc" -> 255).
-    if (ams_id.empty())
-        return false;
-    for (char c : ams_id) {
-        if (c < '0' || c > '9')
-            return false;
-    }
-    try {
-        return IsVirtualSlot(std::stoi(ams_id));
-    } catch (...) {
-        return false;
-    }
-}
-
 static int _hex_digit_to_int(const char c) { return (c >= '0' && c <= '9') ? c - '0' : (c >= 'A' && c <= 'F') ? c - 'A' + 10 : (c >= 'a' && c <= 'f') ? c - 'a' + 10 : -1; }

 wxColour DevAmsTray::decode_color(const std::string &color)
@@ -231,22 +200,18 @@ wxString DevAms::GetDisplayName() const

 int DevAms::GetSlotCount() const
 {
-    // N3S is a 1-slot Bambu contract, so report 1 regardless of whether the
-    // preset bundle is momentarily unavailable (m_trays.size() can be 0).
-    if (GetAmsType() == N3S)
+    // GetAmsType() maps AMS_LITE_MIXED -> AMS_LITE, so N9 reports 4 slots like AMS-Lite.
+    auto ams_type = GetAmsType();
+    if (ams_type == AMS || ams_type == AMS_LITE || ams_type == N3F)
+    {
+        return 4;
+    }
+    else if (ams_type == N3S)
+    {
        return 1;
-
-    if (wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr &&
-        GUI::wxGetApp().preset_bundle->is_bbl_vendor()) {
-        // GetAmsType() maps AMS_LITE_MIXED -> AMS_LITE, so N9 reports 4 slots like AMS-Lite.
-        auto ams_type = GetAmsType();
-        if (ams_type == AMS || ams_type == AMS_LITE || ams_type == N3F)
-        {
-            return 4;
-        }
    }

-    return static_cast<int>(m_trays.size());
+    return 1;
 }

 DevAmsTray* DevAms::GetTray(const std::string& tray_id) const
@@ -337,21 +302,13 @@ int DevFilaSystem::GetExtruderIdByAmsId(const std::string& ams_id) const
    {
        return it->second->GetExtruderId();
    }
-
-    const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr && GUI::wxGetApp().preset_bundle->is_bbl_vendor();
-    if (!is_bbl_vendor && GetOwner()) {
-        for (const auto& tray : GetOwner()->vt_slot) {
-            if (tray.id == ams_id)
-                return VIRTUAL_TRAY_MAIN_ID - std::stoi(ams_id);
-        }
-    }
-
-    if (is_bbl_vendor && ams_id == VIRTUAL_AMS_MAIN_ID_STR)
+    else if (stoi(ams_id) == VIRTUAL_TRAY_MAIN_ID)
+    {
        return MAIN_EXTRUDER_ID;
-    if (is_bbl_vendor && ams_id == VIRTUAL_AMS_DEPUTY_ID_STR)
+    }
+    else if (stoi(ams_id) == VIRTUAL_TRAY_DEPUTY_ID)
+    {
        return DEPUTY_EXTRUDER_ID;
-    if (!is_bbl_vendor && devPrinterUtil::IsVirtualSlot(ams_id)) {
-        return VIRTUAL_TRAY_MAIN_ID - std::stoi(ams_id);
    }

    assert(false && __FUNCTION__);
@@ -368,22 +325,9 @@ std::string DevFilaSystem::GetNozzleFlowStringByAmsId(const std::string& ams_id)
 std::map<int, DevAmsSlotId> DevFilaSystem::GetTrayIndexMap()
 {
    std::map<int, DevAmsSlotId> tray_id_map;
-    const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr && GUI::wxGetApp().preset_bundle->is_bbl_vendor();
-    if (is_bbl_vendor) {
-        tray_id_map[VIRTUAL_TRAY_MAIN_ID]   = DevAmsSlotId{VIRTUAL_TRAY_MAIN_ID, 0};
-        tray_id_map[VIRTUAL_TRAY_DEPUTY_ID] = DevAmsSlotId{VIRTUAL_TRAY_DEPUTY_ID, 0};
-    } else if (GetOwner()) {
-        for (const auto& tray : GetOwner()->vt_slot) {
-            try {
-                const int tray_id = std::stoi(tray.id);
-                tray_id_map[tray_id] = DevAmsSlotId{tray_id, 0};
-            } catch (...) {
-                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << " invalid virtual tray id: " << tray.id;
-            }
-        }
-    }
+    tray_id_map[VIRTUAL_TRAY_MAIN_ID]   = DevAmsSlotId{VIRTUAL_TRAY_MAIN_ID, 0};
+    tray_id_map[VIRTUAL_TRAY_DEPUTY_ID] = DevAmsSlotId{VIRTUAL_TRAY_DEPUTY_ID, 0};

-    int generic_tray_index = 0;
    for (auto& [ams_id, ams_item] : GetAmsList()) {
        for (auto &[slot_id, slot_item] : ams_item->GetTrays()) {
            if (ams_item && slot_item) {
@@ -391,11 +335,9 @@ std::map<int, DevAmsSlotId> DevFilaSystem::GetTrayIndexMap()
                    int ams_id_int  = stoi(ams_id);
                    int slot_id_int = stoi(slot_id);
                    int tray_index  = -1;
-                    if (!is_bbl_vendor) {
-                        tray_index = generic_tray_index + slot_id_int;
-                    } else if (ams_item->GetAmsType() == DevAms::N3S) {
+                    if (ams_item->GetAmsType() == DevAms::N3S) {
                        tray_index = ams_id_int;
-                    } else if (ams_item->GetAmsType() == DevAms::AMS_LITE && ams_item->IsAmsLiteMixed()) {
+                    } else if(ams_item->GetAmsType() == DevAms::AMS_LITE && ams_item->IsAmsLiteMixed()) {
                        tray_index = 24 + slot_id_int;
                    } else {
                        tray_index = (ams_id_int * 4 + slot_id_int);
@@ -406,8 +348,6 @@ std::map<int, DevAmsSlotId> DevFilaSystem::GetTrayIndexMap()
                }
            }
        }
-        if (!is_bbl_vendor)
-            generic_tray_index += static_cast<int>(ams_item->GetTrays().size());
    }

    return  tray_id_map;
@@ -516,13 +456,6 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
                    ams_id_set.insert(it->first);
                }

-                // Bambu trays index their exist bit as ams_id*4+tray_id; a generic (non-Bambu) unit
-                // reports its own lane count, so its trays carry a cumulative lane index instead.
-                // Same index DevFilaSystem::GetTrayIndexMap() builds and the agent sets bits with.
-                const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr &&
-                                           GUI::wxGetApp().preset_bundle->is_bbl_vendor();
-                int generic_tray_base = 0;
-
                for (auto it = j_ams.begin(); it != j_ams.end(); it++)
                {
                    if (!it->contains("id")) continue;
@@ -862,18 +795,7 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS

                                    if (type_id < 4)
                                    {
-                                        if (is_bbl_vendor)
-                                        {
-                                            curr_tray->is_exists = (obj->tray_exist_bits & (1 << (ams_id_int * 4 + tray_id_int))) != 0 ? true : false;
-                                        }
-                                        else
-                                        {
-                                            // A generic unit is not four slots wide, so its trays carry a
-                                            // cumulative lane index across units instead of ams_id*4+tray_id.
-                                            const int tray_bit = generic_tray_base + tray_id_int;
-                                            curr_tray->is_exists = tray_bit >= 0 && tray_bit < 32 &&
-                                                                   (obj->tray_exist_bits & (1UL << tray_bit)) != 0;
-                                        }
+                                        curr_tray->is_exists = (obj->tray_exist_bits & (1 << (ams_id_int * 4 + tray_id_int))) != 0 ? true : false;
                                    }
                                    else if (type_id == DevAms::AMS_LITE_MIXED)
                                    {
@@ -929,9 +851,6 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
                            }
                        }
                    }
-                    if (!is_bbl_vendor && it->contains("tray") && (*it)["tray"].is_array()) {
-                        generic_tray_base += static_cast<int>((*it)["tray"].size());
-                    }
                }
                // remove not in amsList
                for (auto it = ams_id_set.begin(); it != ams_id_set.end(); it++)
@@ -994,8 +913,6 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
            }

            ams->m_exist               = true;
-            ams->m_binded_extruder_set = {ext_id};
-            ams->m_binded_switcher_pos.reset();
            ams->m_current_temperature = u.value("temperature", (float) INVALID_AMS_TEMPERATURE);
            ams->m_humidity_percent    = u.value("humidity_percent", -1);
            ams->m_left_dry_time       = u.value("dry_time_min", 0);
@@ -1078,22 +995,16 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
    }

    // --- external / direct spools -> obj->vt_slot ---
-    // Keep one virtual slot per extruder. The legacy two-extruder mapping uses
-    // 255 for extruder 0 and 254 for extruder 1; continue that sequence for
-    // additional extruders (253, 252, ...).
+    // extruder 0 -> main virtual slot, extruder >0 -> deputy.
    if (obj && data.contains("external") && data["external"].is_array())
    {
-        std::map<int, DevAmsTray> external_slots;
        obj->vt_slot.clear();
        for (const auto& e : data["external"])
        {
            if (!e.is_object())
                continue;
            const int  ext   = e.value("extruder", MAIN_EXTRUDER_ID);
-            if (ext < MAIN_EXTRUDER_ID || ext >= VIRTUAL_TRAY_MAIN_ID)
-                continue;
-
-            const int  vt_id = VIRTUAL_TRAY_MAIN_ID - ext;
+            const int  vt_id = (ext == MAIN_EXTRUDER_ID) ? VIRTUAL_TRAY_MAIN_ID : VIRTUAL_TRAY_DEPUTY_ID;
            DevAmsTray tray(std::to_string(vt_id));
            tray.is_exists       = e.value("loaded", false);
            tray.m_fila_type     = e.value("material", std::string());
@@ -1102,11 +1013,8 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
            tray.nozzle_temp_min = std::to_string(e.value("nozzle_temp_min", 0));
            tray.nozzle_temp_max = std::to_string(e.value("nozzle_temp_max", 0));
            tray.remain          = e.value("remain_percent", -1);
-            external_slots.insert_or_assign(ext, std::move(tray));
+            obj->vt_slot.push_back(tray);
        }
-
-        for (auto& entry : external_slots)
-            obj->vt_slot.push_back(std::move(entry.second));
    }
 }

@@ -348,7 +348,7 @@ public:
    DevAmsTray* GetAmsTray(const std::string& ams_id, const std::string& tray_id) const;
    void        CollectAmsColors(std::vector<wxColour>& ams_colors) const;

-    // Map a linear tray index -> {ams_id, slot_id}. Includes virtual external-spool trays,
+    // Map a linear tray index -> {ams_id, slot_id}. Includes the two virtual (external-spool) trays,
    // N3S single-slot units, and the A2L/N9 AMS-Lite-mixed layout (trays 24-27).
    std::map<int, DevAmsSlotId> GetTrayIndexMap();

@@ -433,4 +433,4 @@ struct DevFilamentDryingPreset
    float filament_dev_ams_drying_heat_distortion_temperature = 0.0f;
 };

-}// namespace Slic3r
+}// namespace Slic3r
@@ -13,7 +13,6 @@
 #include "slic3r/GUI/DeviceCore/DevDefs.h"
 #include "libslic3r/PrintConfig.hpp"
 #include <boost/log/trivial.hpp>
-#include <wx/app.h>
 #include <wx/string.h>
 #include <string>
 #include "libslic3r/CommonDefs.hpp"
@@ -28,7 +27,6 @@
 #include <unordered_map>
 #include <optional>
 #include <cmath>
-#include "slic3r/GUI/GUI_App.hpp"

 using json = nlohmann::json;

@@ -178,52 +176,34 @@ DevFirmwareVersionInfo DevNozzle::GetFirmwareInfo() const
 int DevNozzle::GetLogicExtruderId() const
 {
    int total_ext_count = GetTotalExtruderCount();
-
-    const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr &&
-                               GUI::wxGetApp().preset_bundle->is_bbl_vendor();
-    if (is_bbl_vendor) {
-        if (total_ext_count == 1) {
-            return LOGIC_UNIQUE_EXTRUDER_ID;
-        } else if (total_ext_count == 2) {
-            if (AtLeftExtruder()) {
-                return LOGIC_L_EXTRUDER_ID;
-            } else if (AtRightExtruder()) {
-                return LOGIC_R_EXTRUDER_ID;
-            }
-        }
-
-        assert(0);
+    if (total_ext_count == 1) {
        return LOGIC_UNIQUE_EXTRUDER_ID;
+    } else if (total_ext_count == 2) {
+        if (AtLeftExtruder()) {
+            return LOGIC_L_EXTRUDER_ID;
+        } else if (AtRightExtruder()) {
+            return LOGIC_R_EXTRUDER_ID;
+        }
    }

-    // For some reason, BBL's logical extruder ID is inverted:
-    // physical extruder id = 0 (MAIN_EXTRUDER_ID) vs logical extruder id = 1 (LOGIC_R_EXTRUDER_ID)
-    // Likely because logical id reads from left to right (left = 0, right = 1)
-    // For generic N extruders, this inversion does not apply.
-    if (IsOnRack()) return INVALID_EXTRUDER_ID;
-    return m_nozzle_id;
+    assert(0);
+    return LOGIC_UNIQUE_EXTRUDER_ID;
 }

 int DevNozzle::GetExtruderId() const
 {
-    const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr &&
-                               GUI::wxGetApp().preset_bundle->is_bbl_vendor();
-    if (is_bbl_vendor) {
-        int total_ext_count = GetTotalExtruderCount();
-        if (total_ext_count == 1) {
-            return MAIN_EXTRUDER_ID;
-        } else if (total_ext_count == 2) {
-            if (AtRightExtruder()) {
-                return MAIN_EXTRUDER_ID;
-            } else if (AtLeftExtruder()) {
-                return DEPUTY_EXTRUDER_ID;
-            }
-        }
-    
+    int total_ext_count = GetTotalExtruderCount();
+    if (total_ext_count == 1) {
        return MAIN_EXTRUDER_ID;
+    } else if (total_ext_count == 2) {
+        if (AtRightExtruder()) {
+            return MAIN_EXTRUDER_ID;
+        } else if (AtLeftExtruder()) {
+            return DEPUTY_EXTRUDER_ID;
+        }
    }

-    return m_nozzle_id;
+    return MAIN_EXTRUDER_ID;
 }

 bool DevNozzle::AtLeftExtruder() const
@@ -65,7 +65,6 @@
 #include <unordered_set>
 #include <utility>
 #include <vector>
-#include <wx/app.h>
 #include <wx/colour.h>
 #include <tuple>
 #include <wx/app.h>
@@ -807,12 +806,8 @@ bool MachineObject::is_extrusion_cali_finished()
 DevAmsTray *MachineObject::get_curr_tray()
 {
    const std::string& cur_ams_id = m_extder_system->GetCurrentAmsId();
-    if (devPrinterUtil::IsVirtualSlot(cur_ams_id)) {
-        for (auto& tray : vt_slot) {
-            if (tray.id == cur_ams_id)
-                return &tray;
-        }
-        return nullptr;
+    if (cur_ams_id.compare(std::to_string(VIRTUAL_TRAY_MAIN_ID)) == 0) {
+        return &vt_slot[0];
    }

    DevAms* curr_ams = get_curr_Ams();
@@ -1278,24 +1273,19 @@ int MachineObject::get_bed_temperature_limit()

 bool MachineObject::is_filament_installed()
 {
-    // if (m_extder_system->GetTotalExtderCount() > 0) {
-    //     // right//or single
-    //     auto ext = m_extder_system->m_extders[MAIN_EXTRUDER_ID];
-    //     if (ext.m_ext_has_filament) {
-    //         return true;
-    //     }
-    // }
-    // /*left*/
-    // if (m_extder_system->GetTotalExtderCount() > 1) {
-    //     auto ext = m_extder_system->m_extders[DEPUTY_EXTRUDER_ID];
-    //     if (ext.m_ext_has_filament) {
-    //         return true;
-    //     }
-    // }
-
-    for (auto& ext : m_extder_system->m_extders) {
-        if (ext.m_ext_has_filament)
+    if (m_extder_system->GetTotalExtderCount() > 0) {
+        // right//or single
+        auto ext = m_extder_system->m_extders[MAIN_EXTRUDER_ID];
+        if (ext.m_ext_has_filament) {
            return true;
+        }
+    }
+    /*left*/
+    if (m_extder_system->GetTotalExtderCount() > 1) {
+        auto ext = m_extder_system->m_extders[DEPUTY_EXTRUDER_ID];
+        if (ext.m_ext_has_filament) {
+            return true;
+        }
    }
    return false;
 }
@@ -1808,7 +1798,8 @@ int MachineObject::command_ams_calibrate(int ams_id)
    return command_with_dialog(m_agent->command_ams_calibrate(get_dev_id(), ams_id, MachineObject::m_sequence_id++, is_lan_mode_printer()));
 }

-int MachineObject::command_ams_filament_settings(int ams_id, int slot_id, std::string filament_id, std::string setting_id, std::string tray_color, std::string tray_type, int nozzle_temp_min, int nozzle_temp_max)
+int MachineObject::command_ams_filament_settings(int ams_id, int slot_id, std::string filament_id, std::string setting_id, std::string tray_color, std::string tray_type,
+                                                 int nozzle_temp_min, int nozzle_temp_max, const std::vector<std::string>& tray_colors, int tray_ctype)
 {
    int tag_tray_id = 0;
    int tag_ams_id  = ams_id;
@@ -1837,6 +1828,10 @@ int MachineObject::command_ams_filament_settings(int ams_id, int slot_id, std::s
    j["print"]["nozzle_temp_min"]   = nozzle_temp_min;
    j["print"]["nozzle_temp_max"]   = nozzle_temp_max;
    j["print"]["tray_type"]         = tray_type;
+    if (!tray_colors.empty()) {
+        j["print"]["cols"]  = tray_colors;
+        j["print"]["ctype"] = tray_ctype;
+    }

    return this->publish_json(j);
 }
@@ -2637,10 +2632,13 @@ void MachineObject::reset()
    json empty_j;
    print_json.diff2all_base_reset(empty_j);

-    for (auto& tray : vt_slot)
-        tray.reset();
-    if (vt_slot.size() > 1)
-        vt_slot.erase(vt_slot.begin() + 1, vt_slot.end());
+    for (auto i = 0; i < vt_slot.size(); i++) {
+        vt_slot[i].reset();
+
+        if (i == 1) {
+            vt_slot.erase(vt_slot.begin() + 1);
+        }
+    }
    // why: reset reuses MachineObject, so release its lazy subtask
    // before dropping the pointer to prevent reconnect leaks.
    if (subtask_) {
@@ -4121,28 +4119,25 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
                            if (jj.contains("vir_slot") && jj["vir_slot"].is_array()) {

                                for (auto it = jj["vir_slot"].begin(); it != jj["vir_slot"].end(); it++) {
-                                    try {
-                                        const auto tray_json = it.value().get<json>();
-                                        if (!tray_json.is_object() || !tray_json.contains("id") || !tray_json["id"].is_string())
-                                            continue;
+                                    auto vslot = parse_vt_tray(it.value().get<json>());

-                                        const auto tray_id_str = tray_json["id"].get<std::string>();
-                                        int tray_id = 0;
-                                        const auto result = std::from_chars(tray_id_str.data(), tray_id_str.data() + tray_id_str.size(), tray_id);
-                                        if (result.ec != std::errc{} || result.ptr != tray_id_str.data() + tray_id_str.size()
-                                            || tray_id < 0 || tray_id > VIRTUAL_TRAY_MAIN_ID)
-                                            continue;
-
-                                        auto vslot = parse_vt_tray(tray_json);
-                                        const auto index = static_cast<std::vector<DevAmsTray>::size_type>(VIRTUAL_TRAY_MAIN_ID - tray_id);
-                                        while (vt_slot.size() <= index) {
-                                            const int placeholder_id = VIRTUAL_TRAY_MAIN_ID - static_cast<int>(vt_slot.size());
-                                            vt_slot.emplace_back(std::to_string(placeholder_id));
+                                    if (vslot.id == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
+                                        auto it = std::next(vt_slot.begin(), 0);
+                                        if (it != vt_slot.end()) {
+                                            vt_slot[0] = vslot;
+                                        }
+                                        else {
+                                            vt_slot.push_back(vslot);
                                        }
-                                        vt_slot[index] = vslot;
                                    }
-                                    catch (...) {
-                                        continue;
+                                    else if (vslot.id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
+                                        auto it = std::next(vt_slot.begin(), 1);
+                                        if (it != vt_slot.end()) {
+                                            vt_slot[1] = vslot;
+                                        }
+                                        else {
+                                            vt_slot.push_back(vslot);
+                                        }
                                    }
                                }

@@ -5280,17 +5275,16 @@ DevAmsTray MachineObject::parse_vt_tray(json vtray)

 bool MachineObject::contains_tray(const std::string &ams_id, const std::string &tray_id) const
 {
-    const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr && GUI::wxGetApp().preset_bundle->is_bbl_vendor();
-    if (is_bbl_vendor && ams_id != VIRTUAL_AMS_MAIN_ID_STR && ams_id != VIRTUAL_AMS_DEPUTY_ID_STR)
-        return m_fila_system->GetAmsTray(ams_id, tray_id) != nullptr;
+    if (ams_id != VIRTUAL_AMS_MAIN_ID_STR && ams_id != VIRTUAL_AMS_DEPUTY_ID_STR) {

-    if (!is_bbl_vendor || ams_id == VIRTUAL_AMS_MAIN_ID_STR || ams_id == VIRTUAL_AMS_DEPUTY_ID_STR) {
+        return m_fila_system->GetAmsTray(ams_id, tray_id) != nullptr;
+    } else {
        for (const auto& tray : vt_slot) {
-            if (tray.id == ams_id) return true;
+            if (tray.id == ams_id) { return true; }
        }
    }

-    return !is_bbl_vendor && m_fila_system->GetAmsTray(ams_id, tray_id) != nullptr;
+    return false;
 }

 DevAmsTray MachineObject::get_tray(const std::string &ams_id, const std::string &tray_id) const
@@ -5300,19 +5294,13 @@ DevAmsTray MachineObject::get_tray(const std::string &ams_id, const std::string
        return DevAmsTray(tray_id);
    }

-    const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr && GUI::wxGetApp().preset_bundle->is_bbl_vendor();
-    if (is_bbl_vendor && ams_id != VIRTUAL_AMS_MAIN_ID_STR && ams_id != VIRTUAL_AMS_DEPUTY_ID_STR) {
+    if (ams_id != VIRTUAL_AMS_MAIN_ID_STR && ams_id != VIRTUAL_AMS_DEPUTY_ID_STR) {
        auto tray = m_fila_system->GetAmsTray(ams_id, tray_id);
-        if (tray) return *tray;
+        if (tray) { return *tray;};
    }
-    else if (!is_bbl_vendor || ams_id == VIRTUAL_AMS_MAIN_ID_STR || ams_id == VIRTUAL_AMS_DEPUTY_ID_STR) {
+    else {
        for (const auto &tray : vt_slot) {
-            if (tray.id == ams_id) return tray;
-        }
-
-        if (!is_bbl_vendor) {
-            auto tray = m_fila_system->GetAmsTray(ams_id, tray_id);
-            if (tray) return *tray;
+            if (tray.id == ams_id) { return tray; }
        }
    }

@@ -5495,6 +5483,7 @@ void MachineObject::parse_new_info(json print)
        is_support_pa_mode = (get_flag_bits_no_border(fun2, 3) == 1);
        is_support_remote_dry = (get_flag_bits_no_border(fun2, 5) == 1);
        is_support_check_track_switch_match_slice_printer = get_flag_bits_no_border(fun2, 19) == 1;
+        is_support_filament_manual_multi_color = (get_flag_bits_no_border(fun2, 23) == 1);

        if (DevPrinterConfigUtil::support_print_check_firmware_for_tpu_left(printer_type)) {
            m_firmware_support_print_tpu_left = get_flag_bits_no_border(fun2, 7) == 1;
@@ -674,6 +674,7 @@ public:
    bool is_support_remote_dry = false;
    bool is_support_check_track_switch_match_slice_printer{false};
    bool is_support_pa_mode{false};
+    bool is_support_filament_manual_multi_color{false};
    std::optional<bool> m_firmware_support_print_tpu_left;

    bool installed_upgrade_kit{false};
@@ -804,7 +805,7 @@ public:
    int command_ams_switch_filament(bool switch_filament);
    int command_ams_air_print_detect(bool air_print_detect);
    int command_ams_calibrate(int ams_id);
-    int command_ams_filament_settings(int ams_id, int slot_id, std::string filament_id, std::string setting_id, std::string tray_color, std::string tray_type, int nozzle_temp_min, int nozzle_temp_max);
+    int command_ams_filament_settings(int ams_id, int slot_id, std::string filament_id, std::string setting_id, std::string tray_color, std::string tray_type, int nozzle_temp_min, int nozzle_temp_max, const std::vector<std::string>& tray_colors = {}, int tray_ctype = 2);
    int command_ams_select_tray(std::string tray_id);
    int command_ams_refresh_rfid(int ams_id, int slot_id);
    int command_ams_control(std::string action);
@@ -96,7 +96,7 @@ void FilamentColorCodeQuery::LoadFromLocal()
                    const auto& fila_color_strs = json_data_item["fila_color"].get<std::vector<wxString>>();
                    for (const auto& color_str : fila_color_strs) {
                        if (color_str.size() > 3) /* Skip the value like "#0"*/{
-                            fila_color.m_colors.emplace(wxColour(color_str));
+                            fila_color.AddColor(wxColour(color_str));
                        }
                    }
                }
@@ -87,6 +87,17 @@ struct FilamentColor

 public:
    size_t ColorCount() const noexcept { return m_colors.size(); }
+    // Preserve catalog endpoint order for display while retaining set-based lookup identity.
+    const std::vector<wxColour>& GetColors() const noexcept { return m_color_list; }
+    void AddColor(const wxColour& color)
+    {
+        if (m_colors.insert(color).second) m_color_list.push_back(color);
+    }
+
+private:
+    std::vector<wxColour> m_color_list;
+
+public:

    void EndSet(int ctype)
    {
@@ -816,6 +816,18 @@ DPIFrame(NULL, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, BORDERLESS_FRAME_

 bool MainFrame::handle_global_shortcut(const KeyChord& chord)
 {
+    // ImGui draws its text fields (the text tool's box, a sketch value field) on the GL canvas, so
+    // while one of them is typed into the focused wx window is that canvas or an in-canvas frame:
+    // neither is a wxControl, so focus_keeps_space() cannot see it and CHAR_HOOK takes the chord
+    // here first -- Space opened the Speed Dial, Ctrl+P the Preferences, and the field never saw
+    // the key. ImGui raises WantCaptureKeyboard while one of its items owns the keyboard, so leave
+    // the key to it then. A focused wxControl (text field, list, web view) is untouched: those
+    // keep their own keys, and ImGui's flag can outlive the focus moving to one of them.
+    wxWindow* const focus = wxWindow::FindFocus();
+    ImGuiWrapper* const imgui = wxGetApp().imgui();
+    if (focus != nullptr && imgui != nullptr && imgui->want_keyboard() && dynamic_cast<wxControl*>(focus) == nullptr)
+        return false;
+
    const std::optional<Shortcut> shortcut = wxGetApp().shortcuts().lookup(ShortcutContext::Global, chord);
    if (!shortcut.has_value())
        return false;
@@ -6071,8 +6071,6 @@ void Sidebar::on_bed_type_change(BedType bed_type)
 * - Map key encoding:
 *   - Virtual trays: 0x10000 + vt_tray.id (first/main extruder), or just vt_tray.id (secondary)
 *   - AMS trays: 0x10000 + (ams_id * 4 + slot_id) (main extruder), or (ams_id * 4 + slot_id) (secondary)
- *   - Generic (non-Bambu) units are not four slots wide: their trays index by a cumulative lane
- *     count across units instead of ams_id * 4 + slot_id
 *   - The 0x10000 flag indicates the main/right extruder
 * - Map value: DynamicPrintConfig with filament properties (id, type, color, etc.)
 *
@@ -6138,26 +6136,13 @@ std::map<int, DynamicPrintConfig> Sidebar::build_filament_ams_list(MachineObject
        return std::string();
    };

-    const bool is_bbl_vendor = wxTheApp != nullptr && wxGetApp().preset_bundle != nullptr && wxGetApp().preset_bundle->is_bbl_vendor();
-
    auto list = obj->GetFilaSystem()->GetAmsList();
    for (auto ams : list) {
        int ams_id   = std::stoi(ams.first);
        int extruder = ams.second->GetExtruderId() ? 0 : 0x10000; // Main (first) extruder at right
-        // Bambu units are four slots wide; a generic unit reports its own lane count and its trays
-        // carry a cumulative lane index. The AMS map is keyed by string id, so count preceding units
-        // numerically to keep this the same index the parser and the agent use.
-        int generic_tray_base = 0;
-        if (!is_bbl_vendor) {
-            for (const auto& other : list) {
-                if (std::stoi(other.first) < ams_id)
-                    generic_tray_base += static_cast<int>(other.second->GetTrays().size());
-            }
-        }
        for (auto tray : ams.second->GetTrays()) {
            int  slot_id = std::stoi(tray.first);
-            const int tray_index = is_bbl_vendor ? ams_id * 4 + slot_id : generic_tray_base + slot_id;
-            filament_ams_list.emplace(extruder + tray_index,
+            filament_ams_list.emplace(extruder + (ams_id * 4 + slot_id),
                                      build_tray_config(*tray.second, get_ams_name(ams_id, slot_id), std::to_string(ams_id), std::to_string(slot_id)));
        }
    }
@@ -1,8 +1,6 @@
 #ifndef slic3r_StatusPanel_hpp_
 #define slic3r_StatusPanel_hpp_

-#include <vector>
-
 #include "libslic3r/ProjectTask.hpp"
 #include "DeviceManager.hpp"
 #include "MonitorPage.hpp"
@@ -68,7 +66,6 @@
 #include "StagedBuild.hpp"

 class StepIndicator;
-class wxChoice;

 #define COMMAND_TIMEOUT         5

@@ -143,36 +140,28 @@ class ExtruderImage : public wxWindow
    ScalableBitmap *m_left_extruder_active_empty;
    ScalableBitmap *m_left_extruder_unactive_filled;
    ScalableBitmap *m_left_extruder_unactive_empty;
-
    ScalableBitmap *m_right_extruder_active_filled;
    ScalableBitmap *m_right_extruder_active_empty;
    ScalableBitmap *m_right_extruder_unactive_filled;
    ScalableBitmap *m_right_extruder_unactive_empty;
-    
+
    ScalableBitmap *m_extruder_single_nozzle_empty_load;
    ScalableBitmap *m_extruder_single_nozzle_empty_unload;
    ScalableBitmap *m_extruder_single_nozzle_filled_load;
    ScalableBitmap *m_extruder_single_nozzle_filled_unload;
-    
+
    ExtruderState m_left_ext_state   = {ExtruderState::EMPTY_LOAD};
    ExtruderState m_right_ext_state  = {ExtruderState::EMPTY_LOAD};
    ExtruderState m_single_ext_state = {ExtruderState::EMPTY_LOAD};
-    std::vector<ExtruderState> m_multi_extruder_states;
-    bool m_generic_nozzle_display{false};

 public:
    void update(int nozzle_num, int nozzle_id);
    void update(ExtruderState single_state);
    void update(ExtruderState right_state, ExtruderState left_state);

-    void update(ExtruderState state, int idx);
-
    void msw_rescale();
-    void updateGenericSize();
    void setExtruderCount(int nozzle_num);
-    void setGenericNozzleDisplay(bool enabled);
    void setExtruderUsed(std::string loc);
-    void setExtruderUsed(int nozzle_idx);
    void paintEvent(wxPaintEvent &evt);

    void     render(wxDC &dc);
@@ -506,8 +495,6 @@ protected:
    std::vector<ExtruderImage *> m_extruderImage;

    SwitchBoard *   m_nozzle_btn_panel;
-    wxChoice*       m_generic_nozzle_selector{nullptr};
-    int             m_generic_nozzle_selector_count{0};

    wxStaticText *  m_text_tasklist_caption;

@@ -520,23 +507,10 @@ protected:
    wxBoxSizer *    m_misc_ctrl_sizer;
    StaticBox*      m_fan_panel;
    StaticLine *    m_line_nozzle;
-    wxWindowID      m_nozzle_temp_control_id{wxID_ANY};
-    wxWindow*       m_temp_nozzle_parent{nullptr};
-    wxBoxSizer*     m_temp_nozzle_sizer{nullptr};
-    size_t          m_temp_nozzle_active_count{0};
-    TempInput*      m_tempCtrl_nozzle{nullptr};
+    TempInput*      m_tempCtrl_nozzle;
    int             m_temp_nozzle_timeout{ 0 };
-    TempInput*      m_tempCtrl_nozzle_deputy{nullptr};
+    TempInput*      m_tempCtrl_nozzle_deputy;
    int             m_temp_nozzle_deputy_timeout{ 0 };
-
-    std::vector<TempInput*> m_tempCtrl_nozzles;
-    std::vector<int> m_temp_nozzle_timeouts;
-
-    // Last (dev_id, device toolhead count, preset nozzle count) we warned about, to avoid log spam.
-    std::string m_last_mismatch_dev_id;
-    int         m_last_mismatch_device_count{-1};
-    int         m_last_mismatch_preset_count{-1};
-
    TempInput *     m_tempCtrl_bed;
    int             m_temp_bed_timeout {0};
    TempInput *     m_tempCtrl_chamber;
@@ -576,7 +550,6 @@ protected:

    /* AMS control box <-> live nozzle-rack panel toggle (rack printers only) */
    SwitchBoard*    m_ams_rack_switch{ nullptr };
-    MultiSwitchButton* m_ams_nozzle_switch{ nullptr };

    AMSControl*     m_ams_control;
    StaticBox*      m_ams_control_box;
@@ -651,9 +624,6 @@ public:

    wxBoxSizer *create_temp_axis_group(wxWindow *parent);
    wxBoxSizer *create_temp_control(wxWindow *parent);
-    TempInput* create_nozzle_temp_control(wxWindow *parent, wxWindowID id);
-    void set_temp_input_colors(TempInput* temp_ctrl);
-    void ensure_nozzle_temp_controls(size_t count);
    wxBoxSizer *create_misc_control(wxWindow *parent);
    wxBoxSizer *create_axis_control(wxWindow *parent);
    wxPanel *create_bed_control(wxWindow *parent);
@@ -684,7 +654,6 @@ private:
    friend class MonitorPanel;
    void wire_controls();
    bool load_thumbnail_from_url(const wxString &url, MachineObject *obj);
-    void sync_nozzle_temp_controls(size_t count);

 protected:
    std::shared_ptr<SliceInfoPopup> m_slice_info_popup;
@@ -832,7 +801,6 @@ protected:
    void update_cloud_subtask(MachineObject *obj);
    void update_sdcard_subtask(MachineObject *obj);
    void update_temp_ctrl(MachineObject *obj);
-    void check_extruder_count_mismatch(MachineObject* obj);
    void update_misc_ctrl(MachineObject *obj);
    void update_ams(MachineObject* obj);
    void update_rack(MachineObject* obj);
@@ -244,7 +244,7 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons
    m_sizer_ams_body->Add(m_sizer_ams_area_right, wxALIGN_CENTER, 0);

    m_sizer_body->Add(m_sizer_ams_items, 0, wxALIGN_CENTER, 0);
-    m_sizer_ams_gap = m_sizer_body->Add(0, 0, 1, wxEXPAND | wxTOP, FromDIP(10));
+    m_sizer_body->Add(0, 0, 1, wxEXPAND | wxTOP, FromDIP(10));
    m_sizer_body->Add(m_sizer_ams_body, 0, wxALIGN_CENTER, 0);
    m_sizer_body->Add(m_sizer_down_road, 0, wxALIGN_CENTER, 0);
    m_sizer_body->Add(m_sizer_ams_option, 0, wxEXPAND, 0);
@@ -371,7 +371,7 @@ bool AMSControl::IsAmsInRightPanel(std::string ams_id) {
            return false;
        }
    }
-    else if (m_total_ext_count == 1){
+    else{
        for (auto id : m_item_ids[MAIN_EXTRUDER_ID]){
            if (id == ams_id){
                return true;
@@ -379,10 +379,6 @@ bool AMSControl::IsAmsInRightPanel(std::string ams_id) {
        }
        return false;
    }
-    else {
-        // Generic N Nozzles
-    }
-    return false;
 }

 void AMSControl::AmsSelectedSwitch(wxCommandEvent& event) {
@@ -523,7 +519,7 @@ void AMSControl::msw_rescale()
    m_button_ams_setting_press.msw_rescale();
    m_button_ams_setting->SetBitmap(m_button_ams_setting_normal.bmp());

-    if (m_extruder) m_extruder->msw_rescale();
+    m_extruder->msw_rescale();

    if (m_button_extruder_feed) m_button_extruder_feed->Rescale(); // ORCA
    if (m_button_extruder_back) m_button_extruder_back->Rescale(); // ORCA
@@ -607,8 +603,6 @@ void AMSControl::CreateAms()


 void AMSControl::ClearAms() {
-    m_sizer_ams_items->Clear(false);
-
    m_simplebook_ams_right->DeleteAllPages();
    m_simplebook_ams_left->DeleteAllPages();
    m_simplebook_ams_right->DestroyChildren();
@@ -619,7 +613,7 @@ void AMSControl::ClearAms() {
    m_simplebook_ams_left->Refresh();

    for (auto it : m_ams_preview_list) {
-        if (it.second) it.second->Destroy();
+        delete it.second;
    }
    m_ams_preview_list.clear();
    m_ext_image_list.clear();
@@ -630,181 +624,12 @@ void AMSControl::ClearAms() {
    m_ams_item_list.clear();
    m_sizer_prv_right->Clear();
    m_sizer_prv_left->Clear();
-
-    if (m_nozzle_book) {
-        m_nozzle_book->Destroy();
-        m_nozzle_book = nullptr;
-    } else {
-        for (auto &pane : m_nozzle_panes) {
-            if (pane.preview_panel) pane.preview_panel->Destroy();
-            if (pane.ams_book) pane.ams_book->Destroy();
-            if (pane.page) pane.page->Destroy();
-        }
-    }
-    m_item_ids.assign(std::max(m_total_ext_count, 2), {});
-    m_nozzle_panes.clear();
-    m_active_nozzle_id = 0;
-    m_current_ams.clear();
-    m_current_show_ams_left.clear();
-    m_current_show_ams_right.clear();
+    m_item_ids = { {}, {} };
    pair_id.clear();
 }

-void AMSControl::restore_legacy_ams_layout()
-{
-    m_sizer_ams_items->Clear(false);
-    m_sizer_ams_items->SetOrientation(wxHORIZONTAL);
-    m_sizer_body->GetItem(m_sizer_ams_items)->SetFlag(wxALIGN_CENTER);
-    m_sizer_ams_items->Add(m_panel_prv_left, 0, wxLEFT | wxRIGHT, FromDIP(5));
-    m_sizer_ams_items->Add(m_panel_prv_right, 0, wxLEFT | wxRIGHT, FromDIP(5));
-
-    m_panel_prv_left->Show();
-    m_panel_prv_right->Show();
-    m_simplebook_ams_left->Show();
-    m_simplebook_ams_right->Show();
-    m_panel_down_road->Show();
-    m_sizer_body->Show(m_sizer_ams_body, true);
-    m_sizer_option_mid->Show(m_extruder, true);
-    m_down_road->SetSingleSideLayout(false);
-    m_sizer_ams_gap->SetProportion(1);
-    m_sizer_ams_gap->SetBorder(FromDIP(10));
-    m_down_road->SetNozzleCount(m_total_ext_count);
-}
-
-bool AMSControl::use_multi_nozzle_layout() const
-{
-    const bool is_bbl = wxGetApp().preset_bundle && wxGetApp().preset_bundle->is_bbl_vendor();
-    return is_bbl ? m_total_ext_count > 2 : m_nozzle_book != nullptr;
-}
-
-void AMSControl::CreateAmsMultiNozzle(const std::string &series_name, const std::string &printer_type) {
-    const size_t pane_count = static_cast<size_t>(std::max(m_total_ext_count, 0));
-    m_nozzle_panes.resize(pane_count);
-    m_active_nozzle_id = 0;
-
-    m_sizer_ams_items->Clear(false);
-    m_sizer_ams_items->SetOrientation(wxVERTICAL);
-    m_sizer_body->GetItem(m_sizer_ams_items)->SetFlag(wxALIGN_CENTER);
-    m_sizer_body->Show(m_sizer_ams_body, false);
-    m_sizer_ams_gap->SetProportion(0);
-    m_sizer_ams_gap->SetBorder(0);
-
-    m_panel_prv_left->Hide();
-    m_panel_prv_right->Hide();
-    m_simplebook_ams_left->Hide();
-    m_simplebook_ams_right->Hide();
-    m_panel_down_road->Show();
-    m_sizer_option_mid->Show(m_extruder, true);
-    m_switcher->Hide();
-    m_down_road->SetNozzleCount(1);
-    m_down_road->SetSingleSideLayout(true, AMSPanelPos::LEFT_PANEL);
-    m_down_road->UpdateLeft(1, AMSRoadShowMode::AMS_ROAD_MODE_SINGLE);
-    m_down_road->UpdateRight(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-    m_extruder->updateNozzleNum(1, series_name);
-
-    m_nozzle_book = new wxSimplebook(m_amswin, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0);
-    m_nozzle_book->SetMinSize(wxSize(FromDIP(264), -1));
-    m_nozzle_book->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_BLOCK_BK_COLOUR));
-    m_sizer_ams_items->Add(m_nozzle_book, 0, wxALIGN_CENTER);
-
-    for (size_t nozzle_id = 0; nozzle_id < pane_count; ++nozzle_id) {
-        auto &pane = m_nozzle_panes[nozzle_id];
-        // A generic page is one H2C side. Keep the left-side geometry as the
-        // canonical single-nozzle presentation; the road and AMS item code
-        // still use the same side-specific paths as the legacy layout.
-        pane.panel_pos = AMSPanelPos::LEFT_PANEL;
-        pane.page = new wxPanel(m_nozzle_book, wxID_ANY);
-        pane.page->SetMinSize(wxSize(FromDIP(264), -1));
-        pane.page->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_BLOCK_BK_COLOUR));
-        pane.page_sizer = new wxBoxSizer(wxVERTICAL);
-        pane.page->SetSizer(pane.page_sizer);
-
-        pane.preview_panel = new wxScrolledWindow(pane.page, wxID_ANY);
-        pane.preview_panel->SetScrollRate(10, 0);
-        pane.preview_panel->SetSize(AMS_ITEMS_PANEL_SIZE);
-        pane.preview_panel->SetMinSize(AMS_ITEMS_PANEL_SIZE);
-        pane.preview_panel->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_BLOCK_BK_COLOUR));
-
-        pane.preview_sizer = new wxBoxSizer(wxHORIZONTAL);
-        pane.preview_panel->SetSizer(pane.preview_sizer);
-
-        // Generic lane cards grow to their calculated width for 1-8 lanes. Keep the
-        // book at the legacy minimum, but allow the page to expand to that width.
-        pane.ams_book = new wxSimplebook(pane.page, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0);
-        pane.ams_book->SetMinSize(wxSize(FromDIP(264), -1));
-        pane.ams_book->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_BLOCK_BK_COLOUR));
-        // wxALIGN_CENTER does not centre horizontally inside a HORIZONTAL sizer, so a book wider
-        // than pane.ams_area's own minimum would sit at ams_area's left edge and overflow to the
-        // right, shifting the whole card column off the shared down-road connector axis. A pair of
-        // stretch spacers keeps the book centred on the pane (and thus on the connector) at any
-        // book width; ams_area is expanded below so the spacers have room to work with.
-        pane.ams_area = new wxBoxSizer(wxHORIZONTAL);
-        pane.ams_area->AddStretchSpacer(1);
-        pane.ams_area->Add(pane.ams_book, 0, wxALIGN_CENTER, 0);
-        pane.ams_area->AddStretchSpacer(1);
-
-        pane.page_sizer->Add(pane.preview_panel, 0, wxALIGN_CENTER | wxTOP, FromDIP(5));
-        pane.page_sizer->Add(pane.ams_area, 0, wxEXPAND | wxTOP, FromDIP(10));
-
-        m_nozzle_book->AddPage(pane.page, wxEmptyString, nozzle_id == 0);
-    }
-
-    auto add_info = [this, series_name, printer_type, pane_count](AMSinfo info) {
-        if (pane_count == 0) return;
-
-        info.nozzle_id = std::clamp(info.nozzle_id, 0, static_cast<int>(pane_count) - 1);
-        AddAmsPreview(info, info.ams_type);
-        if (info.ams_type == AMSModel::EXT_AMS && info.cans.size() == 1)
-            AddAms({info}, series_name, printer_type, m_nozzle_panes[info.nozzle_id].panel_pos);
-        else
-            AddAms(info);
-    };
-
-    for (const auto &info : m_ams_info)
-        add_info(info);
-
-    for (auto &info : m_ext_info) {
-        const int virtual_tray_id = std::atoi(info.ams_id.c_str());
-        if (virtual_tray_id <= VIRTUAL_TRAY_MAIN_ID &&
-            virtual_tray_id >= VIRTUAL_TRAY_MAIN_ID - static_cast<int>(pane_count) + 1)
-            info.nozzle_id = VIRTUAL_TRAY_MAIN_ID - virtual_tray_id;
-        add_info(info);
-    }
-
-    for (auto &pane : m_nozzle_panes) {
-        if (pane.ams_book && pane.ams_book->GetPageCount() > 0)
-            pane.ams_book->SetSelection(0);
-        if (pane.preview_sizer) pane.preview_sizer->Layout();
-        if (pane.preview_panel) pane.preview_panel->FitInside();
-        if (pane.ams_book) pane.ams_book->Layout();
-        if (pane.page) pane.page->Layout();
-
-        if (!pane.current_ams.empty()) {
-            auto preview = m_ams_preview_list.find(pane.current_ams);
-            if (preview != m_ams_preview_list.end() && preview->second)
-                preview->second->OnSelected();
-        }
-    }
-
-    if (m_nozzle_book && pane_count > 0) {
-        m_nozzle_book->SetSelection(0);
-        m_current_ams = m_nozzle_panes[0].current_ams;
-        if (!m_current_ams.empty())
-            SwitchAms(m_current_ams);
-        else {
-            m_down_road->UpdateLeft(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-            m_down_road->UpdateRight(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-        }
-    }
-    m_amswin->Layout();
-    m_amswin->Fit();
-    // Generic N Nozzles
-}
-
 void AMSControl::CreateAmsDoubleNozzle(const std::string &series_name, const std::string &printer_type)
 {
-    restore_legacy_ams_layout();
-
    std::vector<AMSinfo> single_info_left;
    std::vector<AMSinfo> single_info_right;

@@ -926,8 +751,6 @@ void AMSControl::CreateAmsDoubleNozzle(const std::string &series_name, const std

 void AMSControl::CreateAmsSingleNozzle(const std::string &series_name, const std::string &printer_type)
 {
-    restore_legacy_ams_layout();
-
    std::vector<int>m_item_nums{0,0};
    std::vector<AMSinfo> single_info;

@@ -1156,17 +979,6 @@ void AMSControl::UpdateAms(const std::string   &series_name,
                if (m_ams_info[i].routes_to_main_extruder() != ams_info[i].routes_to_main_extruder()) {
                    fresh = true;
                }
-                if (m_ams_info[i].nozzle_id != ams_info[i].nozzle_id) {
-                    fresh = true;
-                }
-            }
-
-            for (int i = 0; i < static_cast<int>(m_ext_info.size()); ++i) {
-                if (m_ext_info[i].ams_id != ext_info[i].ams_id ||
-                    m_ext_info[i].nozzle_id != ext_info[i].nozzle_id ||
-                    m_ext_info[i].ext_type != ext_info[i].ext_type) {
-                    fresh = true;
-                }
            }
        }
        else{
@@ -1181,16 +993,11 @@ void AMSControl::UpdateAms(const std::string   &series_name,
        m_dev_id = dev_id;
        if (fresh){
            ClearAms();
-            bool is_bbl = wxGetApp().preset_bundle && wxGetApp().preset_bundle->is_bbl_vendor();
-            if (is_bbl) {
-                if (m_total_ext_count == 1)
-                    CreateAmsSingleNozzle(series_name, printer_type);
-                else if (m_total_ext_count == 2)
-                    CreateAmsDoubleNozzle(series_name, printer_type);
+            if (m_total_ext_count >= 2){
+                CreateAmsDoubleNozzle(series_name, printer_type);
+            }else{
+                CreateAmsSingleNozzle(series_name, printer_type);
            }
-            else
-                CreateAmsMultiNozzle(series_name, printer_type);
-
            SetSize(wxSize(FromDIP(578), -1));
            SetMinSize(wxSize(FromDIP(578), -1));
            Layout();
@@ -1263,7 +1070,7 @@ void AMSControl::UpdateAms(const std::string   &series_name,
    }

    /*update ams extruder*/
-    if (m_total_ext_count <= 2 && m_extruder->updateNozzleNum(m_total_ext_count, series_name))
+    if (m_extruder->updateNozzleNum(m_total_ext_count, series_name))
    {
        m_amswin->Layout();
    }
@@ -1299,15 +1106,7 @@ void AMSControl::AddAmsPreview(AMSinfo info, AMSModel type)
 {
    AMSPreview *ams_prv = nullptr;

-    // Match AddAms: the generic multi-nozzle layout's preview panel is the visible one for
-    // non-Bambu vendors at any extruder count, not only above two.
-    if (use_multi_nozzle_layout()) {
-        const int nozzle_id = std::clamp(info.nozzle_id, 0, m_total_ext_count - 1);
-        auto &pane = m_nozzle_panes[nozzle_id];
-        ams_prv = new AMSPreview(pane.preview_panel, wxID_ANY, info, type);
-        pane.preview_sizer->Add(ams_prv, 0, wxALIGN_CENTER | wxLEFT, FromDIP(6));
-    }
-    else if (info.routes_to_main_extruder())
+    if (info.routes_to_main_extruder())
    {
        ams_prv = new AMSPreview(m_panel_prv_right, wxID_ANY, info, type);
        m_sizer_prv_right->Add(ams_prv, 0, wxALIGN_CENTER | wxLEFT, FromDIP(6));
@@ -1330,54 +1129,6 @@ void AMSControl::AddAmsPreview(AMSinfo info, AMSModel type)
 void AMSControl::createAms(wxSimplebook* parent, int& idx, AMSinfo info, AMSPanelPos pos) {
    auto ams_item = new AmsItem(parent, info, info.ams_type, pos);
    parent->InsertPage(idx, ams_item, wxEmptyString, true);
-
-    // Generic AMS cards may be wider than the legacy 264 DIP page. Propagate
-    // that calculated width through the page and simplebook so 5-8 lanes are
-    // laid out fully instead of being clipped by the old minimum width.
-    if (info.ams_type == AMSModel::GENERIC_AMS) {
-        const int required_width = ams_item->GetMinSize().x;
-        if (required_width > 0) {
-            const int page_width = std::max(parent->GetMinSize().x, required_width);
-            parent->SetMinSize(wxSize(page_width, -1));
-            if (auto *page = parent->GetParent()) {
-                page->SetMinSize(wxSize(std::max(page->GetMinSize().x, page_width), -1));
-                if (auto *nozzle_book = page->GetParent())
-                    nozzle_book->SetMinSize(wxSize(std::max(nozzle_book->GetMinSize().x, page_width), -1));
-            }
-        }
-        // Above eight lanes, AmsItem is a fixed-minimum viewport over a wider
-        // lane strip. Expand the viewport through its page's sizers rather
-        // than propagating the strip's virtual width into the card/book.
-        // Reset back to the centered fixed layout for eight or fewer lanes so a
-        // later small unit is not left in expand mode.
-        const bool generic_lane_layout = !wxGetApp().preset_bundle || !wxGetApp().preset_bundle->is_bbl_vendor();
-        if (generic_lane_layout) {
-            if (auto *page = parent->GetParent()) {
-                auto pane = std::find_if(m_nozzle_panes.begin(), m_nozzle_panes.end(),
-                    [page](const NozzleAmsPane &candidate) { return candidate.page == page; });
-                if (pane != m_nozzle_panes.end() && m_nozzle_book) {
-                    const bool expand_viewport = info.cans.size() > 8;
-                    if (auto *book_item = pane->ams_area->GetItem(pane->ams_book)) {
-                        book_item->SetProportion(expand_viewport ? 1 : 0);
-                        book_item->SetFlag(expand_viewport ? wxEXPAND : wxALIGN_CENTER);
-                    }
-                    // Keep the centring spacers (items 0 and 2) elastic only in the centred layout;
-                    // in the >8-lane viewport they must collapse so the book can fill ams_area.
-                    if (auto *lead = pane->ams_area->GetItem(static_cast<size_t>(0)))
-                        lead->SetProportion(expand_viewport ? 0 : 1);
-                    if (auto *trail = pane->ams_area->GetItem(static_cast<size_t>(2)))
-                        trail->SetProportion(expand_viewport ? 0 : 1);
-                    if (auto *area_item = pane->page_sizer->GetItem(pane->ams_area))
-                        area_item->SetFlag(wxEXPAND | wxTOP);
-                    if (auto *nozzle_book_item = m_sizer_ams_items->GetItem(m_nozzle_book))
-                        nozzle_book_item->SetFlag(expand_viewport ? wxEXPAND : wxALIGN_CENTER);
-                    if (auto *items_item = m_sizer_body->GetItem(m_sizer_ams_items))
-                        items_item->SetFlag(expand_viewport ? wxEXPAND : wxALIGN_CENTER);
-                    m_amswin->Layout();
-                }
-            }
-        }
-    }
    ams_item->set_selection(idx);
    idx++;

@@ -1402,10 +1153,7 @@ AMSRoadShowMode AMSControl::findFirstMode(AMSPanelPos pos) {
        if (item->second->get_ams_model() == AMSModel::EXT_AMS && item->second->get_ext_type() == AMSModelOriginType::LITE_EXT) return AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE;
        return AMSRoadShowMode::AMS_ROAD_MODE_FOUR;
    }
-    else if (item->second->get_can_count() > GENERIC_AMS_SLOT_NUM) {
-        return AMSRoadShowMode::AMS_ROAD_MODE_GENERIC;
-    }
-    else {
+    else{
        for (auto ids : pair_id){
            if (ids.first == ams_id || ids.second == ams_id){
                return AMSRoadShowMode::AMS_ROAD_MODE_DOUBLE;
@@ -1424,13 +1172,8 @@ void AMSControl::createAmsPanel(wxSimplebook *parent, int &idx, std::vector<AMSi
    wxPanel* book_panel = new wxPanel(parent);
    wxBoxSizer* book_sizer = new wxBoxSizer(wxHORIZONTAL);
    book_panel->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
-    // Size the page to the AMS book it becomes, not to the legacy fixed width: an AMS card is
-    // added directly as the book page (so it always spans the book), while a single external
-    // spool is wrapped here. Matching the book keeps the Ext card centred on the same axis as
-    // the AMS cards and the shared down-road connector anchored below them.
-    const wxSize book_panel_size(std::max(parent->GetMinSize().x, AMS_PANEL_SIZE.x), AMS_PANEL_SIZE.y);
-    book_panel->SetSize(book_panel_size);
-    book_panel->SetMinSize(book_panel_size);
+    book_panel->SetSize(AMS_PANEL_SIZE);
+    book_panel->SetMinSize(AMS_PANEL_SIZE);

    AmsItem* ams1 = nullptr, * ams2 = nullptr;
    ams1 = new AmsItem(book_panel, infos[0], infos[0].ams_type, pos);
@@ -1457,14 +1200,6 @@ void AMSControl::createAmsPanel(wxSimplebook *parent, int &idx, std::vector<AMSi
                //book_sizer->Add(ams1, 0, wxALIGN_CENTER_HORIZONTAL, 0);
                book_sizer->Add(ams1, 0, wxLEFT, (book_panel->GetSize().x - ams1->GetSize().x) / 2);
            }
-            else if (pos == AMSPanelPos::SINGLE_PANEL) {
-                // Centre the single external-spool card explicitly, using the same fixed-margin
-                // technique as the Lite-EXT branch above. Two stretch spacers centred the card
-                // against the wrapper's own width rather than the AMS book, which left the card
-                // (and the connector drawn below it) off the book/connector axis.
-                book_sizer->Add(ams1, 0, wxLEFT,
-                                std::max(0, (book_panel_size.x - ams1->GetSize().x) / 2));
-            }
            else{
                auto ext_image = new AMSExtImage(book_panel, pos, m_total_ext_count, false);
                book_sizer->Add(ams1, 0, wxLEFT, FromDIP(30));
@@ -1493,20 +1228,7 @@ void AMSControl::createAmsPanel(wxSimplebook *parent, int &idx, std::vector<AMSi

 void AMSControl::AddAms(AMSinfo info, AMSPanelPos pos)
 {
-    // The generic multi-nozzle layout (non-Bambu vendors) owns the only visible book; a unit must
-    // land there for any extruder count. Keying off m_total_ext_count instead sent 1- and 2-extruder
-    // generic printers into the legacy simplebooks that CreateAmsMultiNozzle hides.
-    if (use_multi_nozzle_layout()) {
-        const int nozzle_id = std::clamp(info.nozzle_id, 0, m_total_ext_count - 1);
-        auto &pane = m_nozzle_panes[nozzle_id];
-        pane.item_ids.push_back(info.ams_id);
-        m_item_ids[nozzle_id].push_back(info.ams_id);
-        if (pane.current_ams.empty()) pane.current_ams = info.ams_id;
-        createAms(pane.ams_book, pane.page_index, info, AMSPanelPos::SINGLE_PANEL);
-        pane.ams_book->Fit();
-        pane.ams_book->Layout();
-    }
-    else if (m_total_ext_count == 2){
+    if (m_total_ext_count > 1){
        if (info.routes_to_main_extruder()){
            createAms(m_simplebook_ams_right, m_right_page_index, info, AMSPanelPos::RIGHT_PANEL);
        }
@@ -1517,9 +1239,6 @@ void AMSControl::AddAms(AMSinfo info, AMSPanelPos pos)
    else if (m_total_ext_count == 1){
        createAms(m_simplebook_ams_left, m_left_page_index, info, AMSPanelPos::LEFT_PANEL);
    }
-    else {
-        // Generic N Nozzles
-    }
    m_simplebook_ams_left->Layout();
    m_simplebook_ams_right->Layout();
    m_simplebook_ams_left->Refresh();
@@ -1550,19 +1269,7 @@ void AMSControl::AddAms(std::vector<AMSinfo> single_info, const std::string &ser
     if (single_info.size() <= 0){
        return;
    }
-    if (use_multi_nozzle_layout()) {
-        const int nozzle_id = std::clamp(single_info.front().nozzle_id, 0, m_total_ext_count - 1);
-        auto &pane = m_nozzle_panes[nozzle_id];
-        for (const auto &info : single_info) {
-            pane.item_ids.push_back(info.ams_id);
-            m_item_ids[nozzle_id].push_back(info.ams_id);
-        }
-        if (pane.current_ams.empty()) pane.current_ams = single_info.front().ams_id;
-        createAmsPanel(pane.ams_book, pane.page_index, single_info, series_name, printer_type, AMSPanelPos::SINGLE_PANEL, m_total_ext_count);
-        pane.ams_book->Fit();
-        pane.ams_book->Layout();
-    }
-    else if (m_total_ext_count == 2) {
+    if (m_total_ext_count == 2) {
        if (single_info[0].routes_to_main_extruder()) {
            createAmsPanel(m_simplebook_ams_right, m_right_page_index, single_info, series_name, printer_type, AMSPanelPos::RIGHT_PANEL, m_total_ext_count);
        }
@@ -1578,9 +1285,6 @@ void AMSControl::AddAms(std::vector<AMSinfo> single_info, const std::string &ser
            createAmsPanel(m_simplebook_ams_left, m_left_page_index, single_info, series_name, printer_type, AMSPanelPos::LEFT_PANEL, m_total_ext_count);
        }
    }
-    else {
-        // Generic N Nozzles
-    }

    m_simplebook_ams_left->Layout();
    m_simplebook_ams_right->Layout();
@@ -1618,21 +1322,6 @@ void AMSControl::AddAms(std::vector<AMSinfo> single_info, const std::string &ser
 void AMSControl::AddAmsPreview(std::vector<AMSinfo>single_info, AMSPanelPos pos) {
    if (single_info.size() <= 0) return;

-    if (use_multi_nozzle_layout()) {
-        const int nozzle_id = std::clamp(single_info.front().nozzle_id, 0, m_total_ext_count - 1);
-        auto &pane = m_nozzle_panes[nozzle_id];
-        for (const auto &info : single_info) {
-            auto *ams_prv = new AMSPreview(pane.preview_panel, wxID_ANY, info, info.ams_type);
-            pane.preview_sizer->Add(ams_prv, 0, wxALIGN_CENTER | wxLEFT, FromDIP(6));
-            ams_prv->Bind(wxEVT_LEFT_DOWN, [this, ams_prv](wxMouseEvent &e) {
-                SwitchAms(ams_prv->get_ams_id());
-                e.Skip();
-            });
-            m_ams_preview_list[info.ams_id] = ams_prv;
-        }
-        return;
-    }
-
    AMSPreview* ams_prv = nullptr;
    AMSPreview* ams_prv2 = nullptr;
    if (pos == AMSPanelPos::RIGHT_PANEL){
@@ -1671,97 +1360,8 @@ void AMSControl::AddAmsPreview(std::vector<AMSinfo>single_info, AMSPanelPos pos)
    }
 }

-void AMSControl::SelectNozzle(int nozzle_id)
-{
-    if (nozzle_id < 0 || nozzle_id >= static_cast<int>(m_nozzle_panes.size()))
-        return;
-
-    if (m_active_nozzle_id == nozzle_id &&
-        (!m_nozzle_book || m_nozzle_book->GetSelection() == nozzle_id))
-        return;
-
-    m_active_nozzle_id = nozzle_id;
-    if (m_nozzle_book && m_nozzle_book->GetSelection() != nozzle_id)
-        m_nozzle_book->SetSelection(nozzle_id);
-    m_current_ams = m_nozzle_panes[nozzle_id].current_ams;
-    if (!m_current_ams.empty()) {
-        SwitchAms(m_current_ams);
-        return;
-    }
-    if (m_down_road) {
-        m_down_road->UpdateLeft(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-        m_down_road->UpdateRight(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-    }
-    if (m_extruder)
-        m_extruder->OnAmsLoading(false, 0);
-    post_event(SimpleEvent(EVT_AMS_SWITCH));
-}
-
 void AMSControl::SwitchAms(std::string ams_id)
 {
-    if (use_multi_nozzle_layout()) {
-        NozzleAmsPane *pane = nullptr;
-        int nozzle_id = -1;
-        for (int index = 0; index < static_cast<int>(m_nozzle_panes.size()); ++index) {
-            auto &candidate = m_nozzle_panes[index];
-            if (std::find(candidate.item_ids.begin(), candidate.item_ids.end(), ams_id) != candidate.item_ids.end()) {
-                pane = &candidate;
-                nozzle_id = index;
-                break;
-            }
-        }
-        if (!pane) return;
-
-        m_active_nozzle_id = nozzle_id;
-        if (m_nozzle_book && m_nozzle_book->GetSelection() != nozzle_id)
-            m_nozzle_book->SetSelection(nozzle_id);
-
-        pane->current_ams = ams_id;
-        m_current_ams = ams_id;
-        m_current_select = ams_id;
-
-        for (const auto &id : pane->item_ids) {
-            auto preview = m_ams_preview_list.find(id);
-            if (preview == m_ams_preview_list.end() || !preview->second) continue;
-            if (id == ams_id) preview->second->OnSelected();
-            else preview->second->UnSelected();
-        }
-
-        auto item = m_ams_item_list.find(ams_id);
-        if (item != m_ams_item_list.end() && item->second) {
-            if (pane->ams_book)
-                pane->ams_book->SetSelection(item->second->get_selection());
-
-            AMSRoadShowMode road_mode = AMSRoadShowMode::AMS_ROAD_MODE_SINGLE;
-            if (item->second->get_can_count() == GENERIC_AMS_SLOT_NUM)
-                road_mode = AMSRoadShowMode::AMS_ROAD_MODE_FOUR;
-            else if (item->second->get_can_count() > GENERIC_AMS_SLOT_NUM)
-                road_mode = AMSRoadShowMode::AMS_ROAD_MODE_GENERIC;
-            else if (item->second->get_ams_model() == AMSModel::N3S_AMS)
-                road_mode = AMSRoadShowMode::AMS_ROAD_MODE_SINGLE_N3S;
-            else if (item->second->get_ams_model() == AMSModel::AMS_LITE ||
-                     (item->second->get_ams_model() == AMSModel::EXT_AMS &&
-                      item->second->get_ext_type() == AMSModelOriginType::LITE_EXT))
-                road_mode = AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE;
-
-            if (m_down_road) {
-                if (pane->panel_pos == AMSPanelPos::LEFT_PANEL) {
-                    m_down_road->UpdateLeft(1, road_mode);
-                    m_down_road->UpdateRight(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-                } else {
-                    m_down_road->UpdateLeft(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-                    m_down_road->UpdateRight(1, road_mode);
-                }
-                m_down_road->UpdatePassRoad(pane->panel_pos, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
-            }
-            if (m_extruder)
-                m_extruder->OnAmsLoading(false, 0);
-        }
-
-        post_event(SimpleEvent(EVT_AMS_SWITCH));
-        return;
-    }
-
    if(ams_id == m_current_show_ams_left || ams_id == m_current_show_ams_right){return;}

    bool is_in_right = IsAmsInRightPanel(ams_id);
@@ -1832,17 +1432,13 @@ void AMSControl::SwitchAms(std::string ams_id)
                    else {
                        AMSRoadShowMode mode = AMSRoadShowMode::AMS_ROAD_MODE_SINGLE;

-                        if (item->get_can_count() > GENERIC_AMS_SLOT_NUM)
-                            mode = AMSRoadShowMode::AMS_ROAD_MODE_GENERIC;
-                        else if (item->get_ams_model() == AMSModel::N3S_AMS)
+                        if (item->get_ams_model() == AMSModel::N3S_AMS)
                            mode = AMSRoadShowMode::AMS_ROAD_MODE_SINGLE_N3S;

-                        if (item->get_can_count() <= GENERIC_AMS_SLOT_NUM) {
-                            for (auto it : pair_id) {
-                                if (it.first == ams_id || it.second == ams_id) {
-                                    mode = AMSRoadShowMode::AMS_ROAD_MODE_DOUBLE;
-                                    break;
-                                }
+                        for (auto it : pair_id) {
+                            if (it.first == ams_id || it.second == ams_id) {
+                                mode = AMSRoadShowMode::AMS_ROAD_MODE_DOUBLE;
+                                break;
                            }
                        }
                        pos == AMSPanelPos::LEFT_PANEL ? m_down_road->UpdateLeft(m_total_ext_count, mode)
@@ -1904,20 +1500,6 @@ void AMSControl::SetExtruder(bool on_off, int nozzle_id, std::string ams_id, std
    AmsItem *item = nullptr;
    if (m_ams_item_list.find(ams_id) != m_ams_item_list.end()) { item = m_ams_item_list[ams_id]; }

-    if (use_multi_nozzle_layout()) {
-        if (nozzle_id < 0 || nozzle_id >= static_cast<int>(m_nozzle_panes.size()))
-            return;
-
-        if (!m_extruder)
-            return;
-
-        if (on_off && item)
-            m_extruder->OnAmsLoading(true, 0, item->GetTagColr(slot_id));
-        else
-            m_extruder->OnAmsLoading(false, 0);
-        return;
-    }
-
    if (on_off && item) {
        auto col = item->GetTagColr(slot_id);
        m_extruder->OnAmsLoading(true, nozzle_id, col);
@@ -2042,69 +1624,6 @@ void AMSControl::SetAmsStep(std::string ams_id, std::string canid, AMSPassRoadTy
    else{
        return;
    }
-
-    if (use_multi_nozzle_layout()) {
-        const int nozzle_id = std::clamp(ams->get_nozzle_id(), 0, m_total_ext_count - 1);
-        if (nozzle_id >= static_cast<int>(m_nozzle_panes.size()))
-            return;
-        auto &pane = m_nozzle_panes[nozzle_id];
-        AMSRoadShowMode road_mode = AMSRoadShowMode::AMS_ROAD_MODE_SINGLE;
-        if (ams->get_can_count() == GENERIC_AMS_SLOT_NUM)
-            road_mode = AMSRoadShowMode::AMS_ROAD_MODE_FOUR;
-        else if (ams->get_can_count() > GENERIC_AMS_SLOT_NUM)
-            road_mode = AMSRoadShowMode::AMS_ROAD_MODE_GENERIC;
-        else if (ams->get_ams_model() == AMSModel::N3S_AMS)
-            road_mode = AMSRoadShowMode::AMS_ROAD_MODE_SINGLE_N3S;
-        else if (ams->get_ams_model() == AMSModel::AMS_LITE ||
-                 (ams->get_ams_model() == AMSModel::EXT_AMS && ams->get_ext_type() == AMSModelOriginType::LITE_EXT))
-            road_mode = AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE;
-
-        if (can_index >= 0 && can_index < static_cast<int>(info.cans.size()) && m_down_road)
-            m_down_road->SetPassRoadColour(pane.panel_pos == AMSPanelPos::LEFT_PANEL,
-                                           info.cans[can_index].material_colour);
-        if (m_down_road) {
-            if (pane.panel_pos == AMSPanelPos::LEFT_PANEL) {
-                m_down_road->UpdateLeft(1, road_mode);
-                m_down_road->UpdateRight(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-            } else {
-                m_down_road->UpdateLeft(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-                m_down_road->UpdateRight(1, road_mode);
-            }
-        }
-
-        int road_length = 0;
-
-        if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_NONE) {
-            ams->SetAmsStep(ams_id, canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
-            if (m_down_road)
-                m_down_road->UpdatePassRoad(pane.panel_pos, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
-            if (m_extruder)
-                m_extruder->OnAmsLoading(false, 0);
-        }
-        else if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP1) {
-            ams->SetAmsStep(ams_id, canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_1);
-            if (m_down_road)
-                m_down_road->UpdatePassRoad(pane.panel_pos, road_length, AMSPassRoadSTEP::AMS_ROAD_STEP_1);
-            if (m_extruder)
-                m_extruder->OnAmsLoading(false, 0);
-        }
-        else if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP2) {
-            ams->SetAmsStep(ams_id, canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_2);
-            if (m_down_road)
-                m_down_road->UpdatePassRoad(pane.panel_pos, road_length, AMSPassRoadSTEP::AMS_ROAD_STEP_2);
-            if (m_extruder)
-                m_extruder->OnAmsLoading(true, 0, ams->GetTagColr(canid));
-        }
-        else if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP3) {
-            ams->SetAmsStep(ams_id, canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_3);
-            if (m_down_road)
-                m_down_road->UpdatePassRoad(pane.panel_pos, road_length, AMSPassRoadSTEP::AMS_ROAD_STEP_3);
-            if (m_extruder)
-                m_extruder->OnAmsLoading(true, 0, ams->GetTagColr(canid));
-        }
-        return;
-    }
-
    if (can_index >= 0 && can_index < info.cans.size())
    {
        m_down_road->SetPassRoadColour(left, info.cans[can_index].material_colour);
@@ -47,20 +47,6 @@ public:
    void on_retry();

 protected:
-    struct NozzleAmsPane
-    {
-        wxPanel*          page{nullptr};
-        wxBoxSizer*       page_sizer{nullptr};
-        wxScrolledWindow* preview_panel{nullptr};
-        wxBoxSizer*       preview_sizer{nullptr};
-        wxSimplebook*     ams_book{nullptr};
-        wxBoxSizer*       ams_area{nullptr};
-        AMSPanelPos        panel_pos{AMSPanelPos::LEFT_PANEL};
-        std::vector<std::string> item_ids;
-        std::string current_ams;
-        int page_index{0};
-    };
-
    std::string  m_current_ams;
    std::string  m_current_slot_left;
    std::string  m_current_slot_right;
@@ -77,9 +63,6 @@ protected:

    std::string                      m_dev_id;
    std::vector<std::vector<std::string>> m_item_ids{ {}, {} };
-    std::vector<NozzleAmsPane>       m_nozzle_panes;
-    wxSimplebook*                    m_nozzle_book{nullptr};
-    int                              m_active_nozzle_id{0};
    std::vector<std::pair<std::string, std::string>> pair_id;

    int         m_total_ext_count = 1;
@@ -120,7 +103,6 @@ protected:
    wxSimplebook *m_simplebook_ams_left{nullptr};
    wxSimplebook *m_simplebook_ams_right{ nullptr };
    wxSimplebook *m_simplebook_bottom{nullptr};
-    wxSizerItem  *m_sizer_ams_gap{nullptr};
    wxPanel      *m_panel_down_road{ nullptr };
    int          m_left_page_index = 0;
    int          m_right_page_index = 0;
@@ -174,7 +156,6 @@ public:
    void createAms(wxSimplebook* parent, int& idx, AMSinfo info, AMSPanelPos pos);
    void createAmsPanel(wxSimplebook *parent, int &idx, std::vector<AMSinfo> infos, const std::string &series_name, const std::string &printer_type, AMSPanelPos pos, int total_ext_num);
    AMSRoadShowMode findFirstMode(AMSPanelPos pos);
-    void restore_legacy_ams_layout();

    AMSModel m_ams_model{AMSModel::EXT_AMS};
    AMSModel m_ext_model{AMSModel::EXT_AMS};
@@ -202,7 +183,6 @@ public:

    void UpdatePassRoad(std::string ams_id, AMSPassRoadType type, AMSPassRoadSTEP step);
    void CreateAms();
-    void CreateAmsMultiNozzle(const std::string& series_name, const std::string& printer_type);
    void CreateAmsDoubleNozzle(const std::string &series_name, const std::string& printer_type);
    void CreateAmsSingleNozzle(const std::string &series_name, const std::string &printer_type);
    void ClearAms();
@@ -230,8 +210,6 @@ public:
    void SetExtruder(bool on_off, int nozzle_id, std::string ams_id, std::string slot_id);
    void SetAmsStep(std::string ams_id, std::string canid, AMSPassRoadType type, AMSPassRoadSTEP step);
    void SwitchAms(std::string ams_id);
-    void SelectNozzle(int nozzle_id);
-    int  GetActiveNozzleId() const { return m_active_nozzle_id; }

    void msw_rescale();
    void on_filament_load(wxCommandEvent &event);
@@ -256,11 +234,6 @@ public:
 private:
    std::string get_filament_id(const std::string& ams_id, const std::string& can_id);

-    // True when AMS units are laid out on the generic multi-nozzle book. Bambu
-    // printers keep the legacy count-based single/double-nozzle layout at any
-    // extruder count; other vendors use the book created for them.
-    bool use_multi_nozzle_layout() const;
-
 public:
    std::string m_current_select;
 };
@@ -38,11 +38,12 @@
 #include <cstddef>
 #include <wx/simplebook.h>
 #include <wx/dcgraph.h>
+#include <wx/graphics.h>
+#include <memory>

 #include <boost/log/trivial.hpp>
 #include <wx/timer.h>
 #include <wx/sizer.h>
-#include <wx/scrolwin.h>

 #include "CalibUtils.hpp"
 #include "slic3r/GUI/wxExtensions.hpp"
@@ -77,48 +78,6 @@ namespace Slic3r { namespace GUI {
 //#define AMS_SINGLE_CAN_SIZE wxSize(FromDIP(78), 144)
 #define AMS_CANS_WINDOW_SIZE wxSize(FromDIP(264), FromDIP(174))
 #define AMS_SINGLE_CAN_SIZE wxSize(FromDIP(78), FromDIP(174))
-
-int generic_ams_layout_width(wxWindow *window, int lane_count)
-{
-    const int base_width = window->FromDIP(264);
-    const int lane_width = window->FromDIP(52);
-    const int lane_gap = window->FromDIP(4);
-    if (lane_count <= 4)
-        return base_width;
-
-    // Lane centers are distributed as width * (index + 1) / (count + 1).
-    // Keep at least one card width plus the requested gap between centers.
-    return std::max(base_width, (lane_count + 1) * (lane_width + lane_gap));
-}
-
-std::vector<int> generic_ams_lane_centers(int lane_count, int width)
-{
-    std::vector<int> centers;
-    if (lane_count <= 0)
-        return centers;
-
-    centers.reserve(lane_count);
-    for (int lane = 0; lane < lane_count; ++lane)
-        centers.push_back(width * (lane + 1) / (lane_count + 1));
-    return centers;
-}
-
-int generic_ams_preview_width(wxWindow *window, int lane_count)
-{
-    const int base_width = window->FromDIP(52);
-    const int lane_width = window->FromDIP(9);
-    const int lane_gap = window->FromDIP(4);
-    if (lane_count <= 0)
-        return base_width;
-
-    return std::max(base_width, lane_count * lane_width + (lane_count + 1) * lane_gap);
-}
-
-bool use_generic_ams_layout(AMSModel model)
-{
-    return model == AMSModel::GENERIC_AMS &&
-           (!wxGetApp().preset_bundle || !wxGetApp().preset_bundle->is_bbl_vendor());
-}
 bool AMSinfo::parse_ams_info(MachineObject *obj, DevAms *ams, bool remain_flag, bool humidity_flag)
 {
    if (!ams) return false;
@@ -213,14 +172,10 @@ void AMSinfo::parse_ext_info(MachineObject* obj, DevAmsTray tray) {
    info.can_id = std::to_string(0);
    this->cans.clear();

-    try {
-        const int virtual_tray_id = std::stoi(tray.id);
-        if (virtual_tray_id >= 0 && virtual_tray_id <= VIRTUAL_TRAY_MAIN_ID)
-            this->nozzle_id = VIRTUAL_TRAY_MAIN_ID - virtual_tray_id;
-    }
-    catch (...) {
+    if (tray.id == std::to_string(VIRTUAL_TRAY_MAIN_ID))
        this->nozzle_id = 0;
-    }
+    else if (tray.id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID))
+        this->nozzle_id = 1;

    if (tray.is_tray_info_ready()) {
        info.ctype = tray.ctype;
@@ -903,11 +858,7 @@ AMSextruder::AMSextruder(wxWindow *parent, wxWindowID id, int nozzle_num, const

 void AMSextruder::TurnOff()
 {
-    if (m_left_extruder) m_left_extruder->TurnOff();
-    if (m_right_extruder) m_right_extruder->TurnOff();
-    for (auto *extruder : m_nozzle_extruders) {
-        if (extruder) extruder->TurnOff();
-    }
+    m_left_extruder->TurnOff();
 }

 void AMSextruder::create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, int nozzle_num)
@@ -933,7 +884,7 @@ void AMSextruder::OnAmsLoading(bool load, int nozzle_id, wxColour col /*= AMS_CO
        m_left_extruder->OnAmsLoading(load, col);
        if (load) m_current_colur_deputy = col;
    }
-    else if (m_nozzle_num == 2){
+    else if (m_nozzle_num > 1){
        if (nozzle_id == MAIN_EXTRUDER_ID) {
            m_right_extruder->OnAmsLoading(load, col);
            if (m_current_colur != col){
@@ -947,15 +898,6 @@ void AMSextruder::OnAmsLoading(bool load, int nozzle_id, wxColour col /*= AMS_CO
            }
        }
    }
-    else if (m_nozzle_num > 2) {
-        if (nozzle_id >= 0 && nozzle_id < static_cast<int>(m_nozzle_extruders.size())) {
-            m_nozzle_extruders[nozzle_id]->OnAmsLoading(load, col);
-            if (load) m_current_colur = col;
-        }
-    }
-    else {
-        // Generic N Nozzles
-    }
 }

 /*return true if something is updated*/
@@ -965,26 +907,12 @@ bool AMSextruder::updateNozzleNum(int nozzle_num, const std::string& series_name
    m_series_name = series_name;
    m_nozzle_num = nozzle_num;
    this->DestroyChildren();
-    m_left_extruder = nullptr;
-    m_right_extruder = nullptr;
-    m_nozzle_extruders.clear();

-    m_bitmap_sizer = new wxBoxSizer(wxHORIZONTAL);
-    if (m_nozzle_num == 1) {
-        if (MachineObject::is_series_n(m_series_name)) {
-            m_left_extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle_n", AMS_EXTRUDER_SINGLE_NOZZLE_N_SIZE);
-        } else if (MachineObject::is_series_x(m_series_name) || MachineObject::is_series_p(m_series_name)) {
-            m_left_extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle_xp", AMS_EXTRUDER_SINGLE_NOZZLE_XP_SIZE);
-        } else {
-            m_left_extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle_xp", AMS_EXTRUDER_SINGLE_NOZZLE_XP_SIZE);
-        }
+    m_right_extruder = new AMSextruderImage(this, wxID_ANY, "right_nozzle", AMS_EXTRUDER_DOUBLE_NOZZLE_BITMAP_SIZE);

-        m_left_extruder->setShowState(true);
-        m_bitmap_sizer->Add(m_left_extruder, 0, wxALIGN_LEFT | wxALIGN_TOP, 0);
-    }
-    else if (m_nozzle_num == 2)
+    wxBoxSizer* m_bitmap_sizer = new wxBoxSizer(wxHORIZONTAL);
+    if (m_nozzle_num >= 2)
    {
-        m_right_extruder = new AMSextruderImage(this, wxID_ANY, "right_nozzle", AMS_EXTRUDER_DOUBLE_NOZZLE_BITMAP_SIZE);
        m_left_extruder = new AMSextruderImage(this, wxID_ANY, "left_nozzle", AMS_EXTRUDER_DOUBLE_NOZZLE_BITMAP_SIZE);
        m_left_extruder->setShowState(true);
        m_right_extruder->setShowState(true);
@@ -992,17 +920,25 @@ bool AMSextruder::updateNozzleNum(int nozzle_num, const std::string& series_name
        m_bitmap_sizer->Add(m_right_extruder, 0, wxLEFT | wxALIGN_TOP, FromDIP(2));
        m_bitmap_sizer->AddSpacer(2);
    }
-    else if (m_nozzle_num > 2) {
-        for (int nozzle_id = 0; nozzle_id < m_nozzle_num; ++nozzle_id) {
-            auto *extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle_n", AMS_EXTRUDER_SINGLE_NOZZLE_N_SIZE);
-            extruder->setShowState(true);
-            m_nozzle_extruders.push_back(extruder);
-            m_bitmap_sizer->Add(extruder, 0, wxALIGN_LEFT | wxALIGN_TOP, 0);
-        }
-    }
    else
    {
-        // Generic N Nozzles
+        if (MachineObject::is_series_n(m_series_name))
+        {
+            m_left_extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle_n", AMS_EXTRUDER_SINGLE_NOZZLE_N_SIZE);
+        }
+        else if(MachineObject::is_series_x(m_series_name) || MachineObject::is_series_p(m_series_name))
+        {
+            m_left_extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle_xp", AMS_EXTRUDER_SINGLE_NOZZLE_XP_SIZE);
+        }
+        else
+        {
+            m_left_extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle_xp", AMS_EXTRUDER_SINGLE_NOZZLE_XP_SIZE);
+        }
+
+        m_left_extruder->setShowState(true);
+        m_right_extruder->setShowState(false);
+        m_bitmap_sizer->Add(m_left_extruder, 0, wxALIGN_LEFT | wxALIGN_TOP, 0);
+        m_bitmap_sizer->Add(m_right_extruder, 0, wxLEFT | wxALIGN_TOP, FromDIP(3));
    }

    SetSizer(m_bitmap_sizer);
@@ -1017,9 +953,6 @@ void AMSextruder::msw_rescale()
    //m_amsSextruder->msw_rescale();
    if (m_left_extruder) m_left_extruder->msw_rescale();
    if (m_right_extruder) m_right_extruder->msw_rescale();
-    for (auto *extruder : m_nozzle_extruders) {
-        if (extruder) extruder->msw_rescale();
-    }
    Layout();
    Update();
    Refresh();
@@ -1478,22 +1411,17 @@ void AMSLib::render_lite_lib(wxDC& dc)

    dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
    if (m_info.material_cols.size() > 1) {
-        int left = FromDIP(10);
-        int gwidth = std::round(libsize.x / (m_info.material_cols.size() - 1));
-        //gradient
+        wxRect color_rect(FromDIP(10), FromDIP(10), libsize.x - FromDIP(18), libsize.y - FromDIP(18));
        if (m_info.ctype == 0) {
-            for (int i = 0; i < m_info.material_cols.size() - 1; i++) {
-                auto rect = wxRect(left, FromDIP(10), libsize.x - FromDIP(18), libsize.y - FromDIP(18));
-                fill_gradient_rect_east(dc, rect, m_info.material_cols[i], m_info.material_cols[i + 1]);
-                left += gwidth;
-            }
+            fill_gradient_rect_east(dc, color_rect, m_info.material_cols.front(), m_info.material_cols.back());
        }
        else {
            int cols_size = m_info.material_cols.size();
            for (int i = 0; i < cols_size; i++) {
                dc.SetBrush(wxBrush(m_info.material_cols[i]));
-                float x = FromDIP(10) + ((float)libsize.x - FromDIP(18)) * i / cols_size;
-                dc.DrawRoundedRectangle(x, FromDIP(10), ((float)libsize.x - FromDIP(17)) / cols_size, libsize.y - FromDIP(20), 0);
+                int x = color_rect.x + color_rect.width * i / cols_size;
+                int next_x = color_rect.x + color_rect.width * (i + 1) / cols_size;
+                dc.DrawRectangle(x, color_rect.y, next_x - x, color_rect.height);
            }
            dc.SetBrush(wxBrush(tmp_lib_colour));
        }
@@ -1585,7 +1513,27 @@ void AMSLib::render_generic_lib(wxDC &dc)
    int top = height - curr_height;

    if (m_ams_model == EXT_AMS){
-        dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(2), size.y - FromDIP(1), m_radius - 1);
+        wxRect color_rect(FromDIP(1), FromDIP(1), size.x - FromDIP(2), size.y - FromDIP(1));
+        if ((m_info.ctype == 0 || m_info.ctype == 1) && m_info.material_cols.size() > 1 && alpha != 0) {
+            if (m_info.ctype == 0) {
+                fill_gradient_rect_east(dc, color_rect, m_info.material_cols.front(), m_info.material_cols.back());
+            }
+            else {
+                int cols_size = static_cast<int>(m_info.material_cols.size());
+                for (int i = 0; i < cols_size; i++) {
+                    dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
+                    dc.SetBrush(wxBrush(m_info.material_cols[i]));
+                    int x      = color_rect.x + color_rect.width * i / cols_size;
+                    int next_x = color_rect.x + color_rect.width * (i + 1) / cols_size;
+                    dc.DrawRectangle(x, color_rect.y, next_x - x, color_rect.height);
+                }
+            }
+            dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
+            dc.SetBrush(wxBrush(tmp_lib_colour));
+        }
+        else {
+            dc.DrawRoundedRectangle(color_rect.x, color_rect.y, color_rect.width, color_rect.height, m_radius - 1);
+        }
        if (alpha == 0) {
            dc.DrawBitmap(m_bitmap_transparent_def.bmp(), FromDIP(2), FromDIP(2));
        }
@@ -2192,10 +2140,7 @@ AMSRoadUpPart::AMSRoadUpPart(wxWindow* parent, wxWindowID id, AMSinfo info, AMSM
    m_ams_model = model;

    if (m_ams_model == AMSModel::GENERIC_AMS){
-        const int width = use_generic_ams_layout(m_ams_model)
-            ? generic_ams_layout_width(this, static_cast<int>(m_amsinfo.cans.size()))
-            : FromDIP(264);
-        create(parent, id, pos, wxSize(width, FromDIP(34)));
+        create(parent, id, pos, wxSize(FromDIP(264), FromDIP(34)));
    }
    else{
        create(parent, id, pos, wxSize(FromDIP(78), FromDIP(34)));
@@ -2307,38 +2252,6 @@ void AMSRoadUpPart::doRender(wxDC& dc)
    dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 2, wxPENSTYLE_SOLID));
    dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));

-    if (use_generic_ams_layout(m_ams_model)) {
-        const int lane_count = static_cast<int>(m_amsinfo.cans.size());
-        if (lane_count <= 0)
-            return;
-
-        const auto lane_centers = generic_ams_lane_centers(lane_count, size.x);
-        const int height = FromDIP(21);
-        for (const int lane_center : lane_centers)
-            dc.DrawLine(lane_center, 0, lane_center, height);
-
-        if (lane_centers.size() > 1)
-            dc.DrawLine(lane_centers.front(), height, lane_centers.back(), height);
-        dc.DrawLine(size.x / 2, height, size.x / 2, size.y);
-
-        if (m_load_step != AMSPassRoadSTEP::AMS_ROAD_STEP_NONE &&
-            m_load_slot_index >= 0 && m_load_slot_index < lane_count) {
-            const int lane_center = lane_centers[m_load_slot_index];
-            dc.SetPen(wxPen(_get_diff_clr(this, m_amsinfo.cans[m_load_slot_index].material_colour), 4, wxPENSTYLE_SOLID));
-            dc.DrawLine(lane_center, 0, lane_center, height);
-            dc.DrawLine(std::min(lane_center, size.x / 2), height,
-                        std::max(lane_center, size.x / 2), height);
-            if (m_load_step == AMSPassRoadSTEP::AMS_ROAD_STEP_2 ||
-                m_load_step == AMSPassRoadSTEP::AMS_ROAD_STEP_3)
-                dc.DrawLine(size.x / 2, height, size.x / 2, size.y);
-        }
-
-        dc.SetPen(*wxTRANSPARENT_PEN);
-        dc.SetBrush(wxBrush(wxColour(194, 194, 194)));
-        dc.DrawRectangle(size.x / 2 - FromDIP(14), height - FromDIP(5), FromDIP(28), FromDIP(10));
-        return;
-    }
-
    if ((m_ams_model == N3S_AMS || m_ams_model == EXT_AMS) && m_amsinfo.cans.size() != 4){
        dc.DrawLine(((float)size.x / 2), (0), ((float)size.x / 2), (size.y));
        if (m_load_step == AMSPassRoadSTEP::AMS_ROAD_STEP_2 || m_load_step == AMSPassRoadSTEP::AMS_ROAD_STEP_3){
@@ -2464,25 +2377,6 @@ void AMSRoadDownPart::UpdateRight(int nozzle_num, AMSRoadShowMode mode)
    Refresh();
 }

-void AMSRoadDownPart::SetNozzleCount(int nozzle_num)
-{
-    const int new_nozzle_num = std::max(1, nozzle_num);
-    if (m_nozzle_num == new_nozzle_num) return;
-
-    m_nozzle_num = new_nozzle_num;
-    Refresh();
-}
-
-void AMSRoadDownPart::SetSingleSideLayout(bool enabled, AMSPanelPos pos)
-{
-    if (m_single_side_layout == enabled && m_single_side_pos == pos)
-        return;
-
-    m_single_side_layout = enabled;
-    m_single_side_pos = pos;
-    Refresh();
-}
-
 void AMSRoadDownPart::OnVamsLoading(bool load, wxColour col /*= AMS_CONTROL_GRAY500*/)
 {
    /*m_vams_loading = load;
@@ -2556,14 +2450,8 @@ void AMSRoadDownPart::doRender(wxDC& dc)
    /*if (m_road_color.Alpha() == 0) { dc.SetPen(wxPen(*wxWHITE, m_passroad_width, wxPENSTYLE_SOLID)); }
    else { dc.SetPen(wxPen(m_road_color, m_passroad_width, wxPENSTYLE_SOLID)); }*/
    dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 2, wxPENSTYLE_SOLID));
-
    auto xpos = left_nozzle_pos.x;
-    if (m_single_side_layout) {
-        dc.DrawLine(size.x / 2, 0, size.x / 2, size.y);
-    }
-    else if (
-        (m_left_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_NONE ||
-         m_right_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_NONE)){
+    if (m_left_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_NONE || m_right_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_NONE){
        auto length = 50;
        if (m_left_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE || m_right_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE)
            length = -13;
@@ -2594,9 +2482,6 @@ void AMSRoadDownPart::doRender(wxDC& dc)
        case AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE:
            dc.DrawLine(left_nozzle_pos.x, 0, left_nozzle_pos.x, size.y);
            break;
-        case AMSRoadShowMode::AMS_ROAD_MODE_GENERIC:
-            // Generic N-lane geometry is intentionally left unimplemented.
-            break;
        default:
            break;
        }
@@ -2624,41 +2509,23 @@ void AMSRoadDownPart::doRender(wxDC& dc)
            dc.DrawLine(left_nozzle_pos.x, (size.y / 2), left_nozzle_pos.x + FromDIP(145), (size.y / 2));
            dc.DrawLine(left_nozzle_pos.x + FromDIP(145), 0, left_nozzle_pos.x + FromDIP(145), (size.y / 2));
            break;
-        case AMSRoadShowMode::AMS_ROAD_MODE_GENERIC:
-            // Generic N-lane geometry is intentionally left unimplemented.
-            break;
        default:
            break;
        }
    }

-    if (m_single_side_layout) {
-        if (m_pass_road_left_step == AMSPassRoadSTEP::AMS_ROAD_STEP_2 ||
-            m_pass_road_left_step == AMSPassRoadSTEP::AMS_ROAD_STEP_3) {
-            dc.SetPen(wxPen(_get_diff_clr(this, m_road_color[1]), 4, wxPENSTYLE_SOLID));
-            dc.DrawLine(size.x / 2, 0, size.x / 2, size.y);
-        }
-        return;
-    }
-
    if (m_right_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE){
-        if (m_nozzle_num == 1) {
-            if (m_right_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_NONE && m_left_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_NONE) {
-                dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (right_nozzle_pos.x), (size.y / 2));
-            }
-            const auto &nozzle_pos = m_single_side_layout && m_single_side_pos == AMSPanelPos::RIGHT_PANEL
-                ? right_nozzle_pos
-                : left_nozzle_pos;
-            dc.DrawLine(nozzle_pos.x, (size.y / 2), nozzle_pos.x, (size.y));
-        }
-        else if (m_nozzle_num == 2) {
+        if (m_nozzle_num == 2) {
            /*dc.DrawLine(FromDIP(left_nozzle_pos.x), FromDIP(size.y / 2), FromDIP(left_nozzle_pos.x), FromDIP(size.y));
            dc.DrawLine(FromDIP(right_nozzle_pos.x), FromDIP(size.y / 2), FromDIP(right_nozzle_pos.x), FromDIP(size.y));*/
            dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (left_nozzle_pos.x), (size.y));
            dc.DrawLine((right_nozzle_pos.x), (size.y / 2), (right_nozzle_pos.x), (size.y));
        }
        else {
-            // Generic N Nozzles
+            if (m_right_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_NONE && m_left_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_NONE) {
+                dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (right_nozzle_pos.x), (size.y / 2));
+            }
+            dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (left_nozzle_pos.x), (size.y));
        }
    }

@@ -2683,16 +2550,10 @@ void AMSRoadDownPart::doRender(wxDC& dc)
                 dc.DrawLine(xpos, size.y / 2, xpos, size.y);*/
                int x   = left_nozzle_pos.x;
                int len = m_right_road_length;
-                if (m_nozzle_num == 1) {
-                    // Keep the single-nozzle path anchored at the left nozzle.
-                }
-                else if (m_nozzle_num == 2) {
+                if (m_nozzle_num == 2) {
                    x   = right_nozzle_pos.x;
                    len = len - 14;
                }
-                else {
-                    // Generic N Nozzles
-                }
                dc.DrawLine(((x)), (size.y / 2), x + FromDIP(len), (size.y / 2));
                dc.DrawLine(x + FromDIP(len), (0), x + FromDIP(len), (size.y / 2));
                dc.DrawLine((x), (size.y / 2), (x), (size.y));
@@ -2700,16 +2561,10 @@ void AMSRoadDownPart::doRender(wxDC& dc)
            else{
                int x = left_nozzle_pos.x;
                int len = m_right_road_length;
-                if (m_nozzle_num == 1) {
-                    // Keep the single-nozzle path anchored at the left nozzle.
-                }
-                else if (m_nozzle_num == 2) {
+                if (m_nozzle_num == 2) {
                    x = right_nozzle_pos.x;
                    len = len - 14;
                }
-                else {
-                    // Generic N Nozzles
-                }
                dc.DrawLine(((x)), (size.y / 2), x + FromDIP(len), (size.y / 2));
                dc.DrawLine(x + FromDIP(len), (0), x + FromDIP(len), (size.y / 2));
                dc.DrawLine((x), (size.y / 2), (x), (size.y));
@@ -2733,7 +2588,7 @@ void AMSRoadDownPart::doRender(wxDC& dc)
 }

 void AMSRoadDownPart::UpdatePassRoad(AMSPanelPos pos, int len, AMSPassRoadSTEP step) {
-    if (m_nozzle_num == 2){
+    if (m_nozzle_num >= 2){
        if (pos == AMSPanelPos::LEFT_PANEL){
            if (m_left_road_length == len && m_pass_road_left_step == step){ return; }
            m_left_road_length = len;;
@@ -2745,7 +2600,7 @@ void AMSRoadDownPart::UpdatePassRoad(AMSPanelPos pos, int len, AMSPassRoadSTEP s
            m_pass_road_right_step = step;
        }
    }
-    else if (m_nozzle_num == 1){
+    else{
        if (pos == AMSPanelPos::LEFT_PANEL) {
            if (m_left_road_length == len && m_pass_road_left_step == step && m_right_road_length == -1) { return; }
            m_left_road_length = len;
@@ -2759,9 +2614,6 @@ void AMSRoadDownPart::UpdatePassRoad(AMSPanelPos pos, int len, AMSPassRoadSTEP s
            m_pass_road_right_step = step;
        }
    }
-    else {
-        // Generic N Nozzles
-    }
    Refresh();
 }

@@ -2780,10 +2632,7 @@ AMSPreview::AMSPreview(wxWindow* parent, wxWindowID id, AMSinfo amsinfo, AMSMode
 {
    wxWindow::Create(parent, id, pos);
    if (itemType == AMSModel::GENERIC_AMS || itemType == AMSModel::AMS_LITE || itemType == AMSModel::N3F_AMS) {
-        if (itemType == AMSModel::GENERIC_AMS && use_generic_ams_layout(itemType))
-            create(parent, id, pos, wxSize(generic_ams_preview_width(this, static_cast<int>(amsinfo.cans.size())), AMS_PREV_FOUR_SIZE.y));
-        else
-            create(parent, id, pos, AMS_PREV_FOUR_SIZE);
+        create(parent, id, pos, AMS_PREV_FOUR_SIZE);
    }
    else {
        create(parent, id, pos, AMS_PREV_SINGLE_SIZE);
@@ -2818,13 +2667,7 @@ void AMSPreview::UpdateInfo(AMSinfo amsinfo)
    m_amsinfo = amsinfo;
    m_ams_item_type = amsinfo.ams_type;

-    if (m_ams_item_type == AMSModel::GENERIC_AMS && use_generic_ams_layout(m_ams_item_type)) {
-        const wxSize generic_size(generic_ams_preview_width(this, static_cast<int>(m_amsinfo.cans.size())), AMS_PREV_FOUR_SIZE.y);
-        SetSize(generic_size);
-        SetMinSize(generic_size);
-        SetMaxSize(generic_size);
-    }
-    else if (m_ams_item_type == AMSModel::GENERIC_AMS || m_ams_item_type == AMSModel::AMS_LITE || m_ams_item_type == AMSModel::N3F_AMS) {
+    if (m_ams_item_type == AMSModel::GENERIC_AMS || m_ams_item_type == AMSModel::AMS_LITE || m_ams_item_type == AMSModel::N3F_AMS) {
        SetMinSize(AMS_PREV_FOUR_SIZE);
        SetMaxSize(AMS_PREV_FOUR_SIZE);
    } else {
@@ -2932,41 +2775,8 @@ void AMSPreview::doRender(wxDC &dc)
    dc.DrawRoundedRectangle(0, 0, size.x, size.y, FromDIP(3));

    auto left = 0;
-    // Generic AMS previews use the same normalized lane centers as the card row and connector.
-    if (m_ams_item_type == AMSModel::GENERIC_AMS && use_generic_ams_layout(m_ams_item_type)) {
-        const int lane_count = static_cast<int>(m_amsinfo.cans.size());
-        const auto lane_centers = generic_ams_lane_centers(lane_count, size.x);
-        const int cube_width = FromDIP(9);
-        const int cube_height = FromDIP(14);
-
-        for (int lane = 0; lane < lane_count; ++lane) {
-            const Caninfo &can = m_amsinfo.cans[lane];
-            const int cube_left = lane_centers[lane] - cube_width / 2;
-            const int cube_top = (size.y - cube_height) / 2;
-            wxRect rect(cube_left, cube_top, cube_width, cube_height);
-
-            if (can.material_colour.Alpha() == 0) {
-                if (wxGetApp().dark_mode())
-                    dc.DrawBitmap(m_ts_bitmap_cube_dark.bmp(), cube_left - FromDIP(1), (size.y - m_ts_bitmap_cube_dark.GetBmpHeight()) / 2);
-                else
-                    dc.DrawBitmap(m_ts_bitmap_cube.bmp(), cube_left - FromDIP(1), (size.y - m_ts_bitmap_cube.GetBmpHeight()) / 2);
-            }
-            else if (can.material_state == AMSCanType::AMS_CAN_TYPE_EMPTY) {
-                dc.SetPen(wxPen(wxColor(0, 0, 0)));
-                dc.DrawLine(rect.GetRight() - FromDIP(1), rect.GetTop() + FromDIP(1),
-                            rect.GetLeft() + FromDIP(1), rect.GetBottom() - FromDIP(1));
-            }
-            else {
-                wxColour color = can.material_colour;
-                change_the_opacity(color);
-                dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
-                dc.SetBrush(wxBrush(color));
-                dc.DrawRoundedRectangle(rect, 2);
-            }
-        }
-    }
-    // four slot
-    else if (m_ams_item_type != AMSModel::EXT_AMS && m_ams_item_type != AMSModel::N3S_AMS){
+    //four slot
+    if (m_ams_item_type != AMSModel::EXT_AMS && m_ams_item_type != AMSModel::N3S_AMS){
        left =  FromDIP(8);
        for (std::vector<Caninfo>::iterator iter = m_amsinfo.cans.begin(); iter != m_amsinfo.cans.end(); iter++) {

@@ -3051,30 +2861,38 @@ void AMSPreview::doRender(wxDC &dc)
        //dc.DrawRoundedRectangle((size.x - rec_size.x) / 2, (size.y - rec_size.y) / 2, rec_size.x, rec_size.y, FromDIP(2));
        if (iter.material_cols.size() > 1)
        {
-            int fleft = (size.x - AMS_ITEM_CUBE_SIZE.x) / 2;
-
-            float total_width = AMS_ITEM_CUBE_SIZE.x;
-            int gwidth = (total_width / (iter.material_cols.size()));
-            if (iter.ctype == 0) {
-                for (int i = 0; i < iter.material_cols.size() - 1; i++) {
-
-                    if ((fleft + gwidth) > (AMS_ITEM_CUBE_SIZE.x)) {
-                        gwidth = (fleft + AMS_ITEM_CUBE_SIZE.x) - fleft;
-                    }
-
-                    auto rect = wxRect(fleft, (size.y - AMS_ITEM_CUBE_SIZE.y) / 2, gwidth, AMS_ITEM_CUBE_SIZE.y);
-                    fill_gradient_rect_east(dc, rect, iter.material_cols[i], iter.material_cols[i + 1]);
-                    fleft += gwidth;
-                }
+            const wxSize swatch_size = m_ams_item_type == AMSModel::N3S_AMS ? AMS_ITEM_CUBE_SIZE : AMS_ITEM_CUBE_SIZE2;
+            const wxRect rect((size.x - swatch_size.x) / 2, (size.y - swatch_size.y) / 2, swatch_size.x, swatch_size.y);
+            const int radius = m_ams_item_type == AMSModel::N3S_AMS ? 0 : FromDIP(3);
+            std::unique_ptr<wxGraphicsContext> owned_gc;
+            wxGraphicsContext* gc = dc.GetGraphicsContext();
+            if (!gc) {
+                owned_gc.reset(wxGraphicsContext::CreateFromUnknownDC(dc));
+                gc = owned_gc.get();
            }
-            else {
-                int cols_size = iter.material_cols.size();
-                for (int i = 0; i < cols_size; i++) {
-                    dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
-                    dc.SetBrush(wxBrush(iter.material_cols[i]));
-                    float x = (size.x - AMS_ITEM_CUBE_SIZE.x) / 2 + total_width * i / cols_size;
-                    dc.DrawRectangle(x, (size.y - AMS_ITEM_CUBE_SIZE.y) / 2, total_width / cols_size, AMS_ITEM_CUBE_SIZE.y);
+            if (gc) {
+                wxGraphicsGradientStops stops(iter.material_cols.front(), iter.material_cols.back());
+                const size_t count = iter.material_cols.size();
+                if (iter.ctype == 0) {
+                    for (size_t i = 1; i + 1 < count; ++i)
+                        stops.Add(iter.material_cols[i], static_cast<float>(i) / (count - 1));
+                } else {
+                    // Two stops at each boundary keep multicolour bands distinct.
+                    for (size_t i = 1; i < count; ++i) {
+                        const float position = static_cast<float>(i) / count;
+                        stops.Add(iter.material_cols[i - 1], position);
+                        stops.Add(iter.material_cols[i], position);
+                    }
                }
+                gc->PushState();
+                gc->SetPen(*wxTRANSPARENT_PEN);
+                gc->SetBrush(gc->CreateLinearGradientBrush(rect.x, rect.y, rect.x + rect.width, rect.y, stops));
+                gc->DrawRoundedRectangle(rect.x, rect.y, rect.width, rect.height, radius);
+                gc->PopState();
+            } else {
+                dc.SetPen(*wxTRANSPARENT_PEN);
+                dc.SetBrush(iter.material_colour);
+                dc.DrawRoundedRectangle(rect, radius);
            }
        }
        else {
@@ -3365,19 +3183,10 @@ AmsItem::AmsItem(wxWindow *parent,AMSinfo info,  AMSModel model, AMSPanelPos pos
    m_panel_pos = pos;

    if (m_ams_model == AMSModel::GENERIC_AMS){
-        const int lane_count = static_cast<int>(m_info.cans.size());
-        const int width = use_generic_ams_layout(m_ams_model) && lane_count <= 8
-            ? generic_ams_layout_width(this, lane_count)
-            : FromDIP(264);
-        const wxSize generic_size(width, FromDIP(174));
-        wxWindow::Create(parent, wxID_ANY, wxDefaultPosition, generic_size);
-        SetSize(generic_size);
-        SetMinSize(generic_size);
-        // For large lane counts the card is a viewport, not the lane strip. Let
-        // its parent allocate the available width; the scrolled child retains
-        // the wider virtual content size.
-        if (!(use_generic_ams_layout(m_ams_model) && lane_count > 8))
-            SetMaxSize(generic_size);
+        wxWindow::Create(parent, wxID_ANY, wxDefaultPosition, AMS_CANS_WINDOW_SIZE);
+        SetSize(AMS_CANS_WINDOW_SIZE);
+        SetMinSize(AMS_CANS_WINDOW_SIZE);
+        SetMaxSize(AMS_CANS_WINDOW_SIZE);
    }
    else{
        wxWindow::Create(parent, wxID_ANY, wxDefaultPosition, AMS_SINGLE_CAN_SIZE);
@@ -3403,43 +3212,12 @@ void AmsItem::create(wxWindow *parent)
    if (m_ams_model != AMSModel::AMS_LITE) {
        sizer_can = new wxBoxSizer(wxHORIZONTAL);
        sizer_item = new wxBoxSizer(wxVERTICAL);
-        const bool generic_layout = use_generic_ams_layout(m_ams_model);
-        const int lane_count = static_cast<int>(m_info.cans.size());
-        const int content_width = generic_layout ? generic_ams_layout_width(this, lane_count) : 0;
-        const bool scroll_lanes = generic_layout && lane_count > 8;
-        const auto lane_centers = generic_layout
-            ? generic_ams_lane_centers(lane_count, content_width)
-            : std::vector<int>();
-
-        m_can_parent = this;
-        if (scroll_lanes) {
-            m_can_scroll = new wxScrolledWindow(this, wxID_ANY);
-            m_can_scroll->SetScrollRate(FromDIP(10), 0);
-            m_can_scroll->SetMinSize(wxSize(FromDIP(264), FromDIP(143)));
-            m_can_scroll->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
-            m_can_scroll_sizer = new wxBoxSizer(wxVERTICAL);
-            m_can_scroll->SetSizer(m_can_scroll_sizer);
-            m_can_parent = m_can_scroll;
-        }
-
-        int previous_right = 0;
-        for (int can_index = 0; can_index < lane_count; ++can_index) {
-            if (generic_layout) {
-                const int left = lane_centers[can_index] - FromDIP(26);
-                sizer_can->AddSpacer(std::max(0, left - previous_right));
-                AddCan(m_info.cans[can_index], m_can_count, m_info.cans.size(), sizer_can);
-                previous_right = left + FromDIP(52);
-            }
-            else {
-                AddCan(m_info.cans[can_index], m_can_count, m_info.cans.size(), sizer_can);
-            }
+        auto it = m_info.cans.begin();
+        for (; it != m_info.cans.end(); it++) {
+            AddCan(*it, m_can_count, m_info.cans.size(), sizer_can);
            m_can_count++;
        }
-        if (generic_layout)
-            sizer_can->AddSpacer(std::max(0, content_width - previous_right));
-        if (generic_layout)
-            sizer_can->SetMinSize(wxSize(content_width, -1));
-
+        it = m_info.cans.begin();
        //auto        road_panel = new wxWindow(this, wxID_ANY);
        //auto        road_panel = new wxPanel(this, wxID_ANY);
        //road_panel->SetSize(AMS_CAN_ROAD_SIZE);
@@ -3454,18 +3232,11 @@ void AmsItem::create(wxWindow *parent)
                sizer_item->Add(m_ext_image, 0, wxALIGN_CENTER, 0);
            }
        }
-        m_panel_road = new AMSRoadUpPart(m_can_parent, wxID_ANY, m_info, m_ams_model);
+        m_panel_road = new AMSRoadUpPart(this, wxID_ANY, m_info, m_ams_model);

-        if (scroll_lanes) {
-            m_can_scroll_sizer->Add(sizer_can, 0, wxALIGN_LEFT, 0);
-            m_can_scroll_sizer->Add(m_panel_road, 0, wxALIGN_LEFT, 0);
-            sizer_item->Add(m_can_scroll, 1, wxEXPAND);
-        }
-        else {
-            sizer_item->Add(sizer_can, 0, wxALIGN_CENTER_HORIZONTAL, 0);
-            //sizer_item->Add(m_panel_road, 0, wxALIGN_CENTER_HORIZONTAL, 0);
-            sizer_item->Add(m_panel_road, 1, wxEXPAND);
-        }
+        sizer_item->Add(sizer_can, 0, wxALIGN_CENTER_HORIZONTAL, 0);
+        //sizer_item->Add(m_panel_road, 0, wxALIGN_CENTER_HORIZONTAL, 0);
+        sizer_item->Add(m_panel_road, 1, wxEXPAND);

        SetSizer(sizer_item);
    }
@@ -3489,17 +3260,13 @@ void AmsItem::create(wxWindow *parent)

    Layout();
    Fit();
-    if (m_can_scroll) {
-        m_can_scroll->Layout();
-        m_can_scroll->FitInside();
-    }
    Thaw();
    //Refresh();
 }

 void AmsItem::AddCan(Caninfo caninfo, int canindex, int maxcan, wxBoxSizer* sizer)
 {
-    auto        amscan = new wxWindow(m_can_parent ? m_can_parent : this, wxID_ANY);
+    auto        amscan = new wxWindow(this, wxID_ANY);

    amscan->SetSize(wxSize(FromDIP(52), FromDIP(109)));
    amscan->SetMinSize(wxSize(FromDIP(52), FromDIP(109)));
@@ -3580,8 +3347,7 @@ void AmsItem::AddCan(Caninfo caninfo, int canindex, int maxcan, wxBoxSizer* size
    amscan->Layout();
    amscan->Fit();

-    const int margin = use_generic_ams_layout(m_ams_model) ? 0 : FromDIP(5);
-    sizer->Add(amscan, 0, wxUP | wxLEFT | wxRIGHT, margin);
+    sizer->Add(amscan, 0, wxUP | wxLEFT | wxRIGHT, FromDIP(5));

    m_can_lib_list[caninfo.can_id] = m_panel_lib;
    //m_can_road_list[caninfo.can_id] = m_panel_road;
@@ -3706,10 +3472,6 @@ void AmsItem::UpdateInfo(AMSinfo info)
    }

    Layout();
-    if (m_can_scroll) {
-        m_can_scroll->Layout();
-        m_can_scroll->FitInside();
-    }
 }

 void AmsItem::SetDefSelectCan()
@@ -30,7 +30,6 @@
 #include <wx/string.h>
 #include <wx/timer.h>
 #include <wx/sizer.h>
-#include <wx/scrolwin.h>

 #include "slic3r/GUI/DeviceCore/DevFilaSwitch.h" // Orca: DevFilaSwitch::SwitchPos for inlet-aware AMS placement

@@ -97,7 +96,6 @@ enum class AMSRoadShowMode : int {
    AMS_ROAD_MODE_SINGLE,
    AMS_ROAD_MODE_SINGLE_N3S,
    AMS_ROAD_MODE_AMS_LITE,
-    AMS_ROAD_MODE_GENERIC,
    AMS_ROAD_MODE_NONE
 };

@@ -482,7 +480,6 @@ public:
    //AMSextruderImage *m_amsSextruder{nullptr};
    AMSextruderImage* m_left_extruder = nullptr;
    AMSextruderImage* m_right_extruder = nullptr;
-    std::vector<AMSextruderImage*> m_nozzle_extruders;
    AMSextruder(wxWindow *parent, wxWindowID id, int nozzle_num, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize);
    ~AMSextruder();

@@ -684,8 +681,6 @@ public:
    // void                         Update(AMSRoadDownPartMode nozzle, AMSRoadShowMode left_mode, AMSRoadShowMode right_mode, int left_len, int right_len);
    void UpdateLeft(int nozzle_num, AMSRoadShowMode mode);
    void UpdateRight(int nozzle_num, AMSRoadShowMode mode);
-    void SetNozzleCount(int nozzle_num);
-    void SetSingleSideLayout(bool enabled, AMSPanelPos pos = AMSPanelPos::LEFT_PANEL);

    void OnVamsLoading(bool load, wxColour col = AMS_CONTROL_GRAY500);
    void SetPassRoadColour(bool left, wxColour col);
@@ -703,8 +698,6 @@ private:
    AMSRoadShowMode m_left_rode_mode       = {AMSRoadShowMode::AMS_ROAD_MODE_FOUR};
    AMSRoadShowMode m_right_rode_mode      = {AMSRoadShowMode::AMS_ROAD_MODE_FOUR};
    bool            m_selected             = {false};
-    bool            m_single_side_layout   = {false};
-    AMSPanelPos     m_single_side_pos     = {AMSPanelPos::LEFT_PANEL};

    int             m_left_road_length     = {-1};
    int             m_right_road_length    = {-1};
@@ -871,9 +864,6 @@ private:

    std::map<std::string, AMSLib*>      m_can_lib_list;
    //std::map<std::string, AMSRoad*>     m_can_road_list;
-    wxScrolledWindow* m_can_scroll = { nullptr };
-    wxBoxSizer*       m_can_scroll_sizer = { nullptr };
-    wxWindow*         m_can_parent = { nullptr };
    AMSRoadUpPart* m_panel_road = { nullptr };
    std::map<std::string, AMSrefresh*>  m_can_refresh_list;
    AMSHumidity* m_humidity = { nullptr };
@@ -420,14 +420,6 @@ ExtruderBadge::ExtruderBadge(wxWindow* parent) : wxPanel(parent)

 void ExtruderBadge::SetExtruderInfo(int extruder_id, const std::string& diameter, const NozzleVolumeType& volume_type)
 {
-    // The badge renders exactly two extruders (left/right). A generic non-BBL printer with
-    // N > 2 can report an out-of-range id here (see MultiNozzleStatusTable::UpdateRackInfo);
-    // reject it rather than writing past the two-element lists.
-    if (extruder_id < 0 || extruder_id >= static_cast<int>(m_diameter_list.size())) {
-        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": out-of-range extruder_id " << extruder_id;
-        return;
-    }
-
    m_diameter_list[extruder_id] = diameter;
    m_volume_type_list[extruder_id] = volume_type;

@@ -875,21 +867,14 @@ void MultiNozzleStatusTable::UpdateRackInfo(std::weak_ptr<DevNozzleRack> rack)
        bool has_right = false;
        for (auto& elem : nozzles_in_extruder) {
            auto& nozzle = elem.second;
-
-            int extruder_id{};
-            if (wxGetApp().preset_bundle && wxGetApp().preset_bundle->is_bbl_vendor()) {
-                extruder_id = nozzle.AtLeftExtruder() ? 0 : 1;
-                if (nozzle.AtRightExtruder())
-                    has_right = true;
-            }
-            else
-                extruder_id = nozzle.GetExtruderId();
+            int extruder_id = nozzle.AtLeftExtruder() ? 0 : 1;
+            if (nozzle.AtRightExtruder())
+                has_right = true;

            NozzleVolumeType volume_type = DevNozzle::ToNozzleVolumeType(nozzle.m_nozzle_flow);

            m_badge->SetExtruderInfo(extruder_id, format_diameter_to_str(nozzle.GetNozzleDiameter()), volume_type);
        }
-        // TODO: Update for N extruders
        m_badge->SetExtruderValid(has_right);
    }
 }
@@ -184,9 +184,6 @@ void TempInput::SetFinish()
    wxCommandEvent event(wxCUSTOMEVT_SET_TEMP_FINISH);
    event.SetInt(temp_type);
    event.SetString(wxString::Format("%d", m_input_type));
-    // N-extruder temp controls all share TEMP_OF_NORMAL_TYPE, so the string payload above can't
-    // tell them apart; carry widget identity so the listener can find which one fired.
-    event.SetEventObject(this);
    wxPostEvent(this->GetParent(), event);
 }

@@ -38,7 +38,6 @@
 #include <boost/log/trivial.hpp>
 #include <algorithm>
 #include <chrono>
-#include <cstddef>
 #include <cstdint>
 #include <cctype>
 #include <ios>
@@ -62,42 +61,6 @@ namespace websocket = beast::websocket;
 namespace net       = boost::asio;
 using tcp           = net::ip::tcp;

-// Decimal value of a string that is nothing but digits, or -1 when it is empty or not a number.
-int decimal_number(const std::string& digits)
-{
-    if (digits.empty() || !std::all_of(digits.begin(), digits.end(), [](unsigned char c) { return std::isdigit(c) != 0; }))
-        return -1;
-    try {
-        return std::stoi(digits);
-    } catch (...) {
-        return -1;
-    }
-}
-
-// Lane database keys address a lane either as "T<N>" (0-based tool index) or as "lane<N>"
-// (1-based, the AFC/Happy Hare style). Returns -1 when the key carries no usable lane number.
-int lane_index_from_key(const std::string& lane_key)
-{
-    if (lane_key.size() > 1 && (lane_key[0] == 'T' || lane_key[0] == 't'))
-        return decimal_number(lane_key.substr(1));
-    if (lane_key.size() > 4 && lane_key.compare(0, 4, "lane") == 0) {
-        const int lane_number = decimal_number(lane_key.substr(4));
-        return lane_number > 0 ? lane_number - 1 : -1;
-    }
-    return -1;
-}
-
-// AFC names toolheads "extruder", "extruder1", ... and derives the toolhead index from the name
-// itself (AFC_lane.lane_extruder_index): no suffix is 0, otherwise the suffix is the index.
-int extruder_index_from_name(const std::string& toolhead)
-{
-    if (toolhead == "extruder")
-        return 0;
-    if (toolhead.size() > 8 && toolhead.compare(0, 8, "extruder") == 0)
-        return decimal_number(toolhead.substr(8));
-    return -1;
-}
-
 struct WsEndpoint
 {
    std::string host;
@@ -480,7 +443,19 @@ int MoonrakerPrinterAgent::set_queue_on_main_fn(QueueOnMainFn fn)

 void MoonrakerPrinterAgent::build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays)
 {
+
+    // Look up MachineObject via DeviceManager
+    auto* dev_manager = GUI::wxGetApp().getDeviceManager();
+    if (!dev_manager) {
+        return;
+    }
+    MachineObject* obj = dev_manager->get_my_machine(device_info.dev_id);
+    if (!obj) {
+        return;
+    }
+
    // Build BBL-format JSON for DevFilaSystemParser::ParseV1_0
+    nlohmann::json ams_json = nlohmann::json::object();
    nlohmann::json ams_array = nlohmann::json::array();

    // Calculate ams_exist_bits and tray_exist_bits
@@ -488,9 +463,11 @@ void MoonrakerPrinterAgent::build_ams_payload(int ams_count, int max_lane_index,
    unsigned long tray_exist_bits = 0;

    for (int ams_id = 0; ams_id < ams_count; ++ams_id) {
-        if (ams_id < 32) {
-            ams_exist_bits |= (1UL << ams_id);
-        }
+        ams_exist_bits |= (1 << ams_id);
+
+        nlohmann::json ams_unit = nlohmann::json::object();
+        ams_unit["id"] = std::to_string(ams_id);
+        ams_unit["info"] = "0002";  // treat as AMS_LITE 

        nlohmann::json tray_array = nlohmann::json::array();
        int max_slot_in_this_ams = std::min(3, max_lane_index - ams_id * 4);
@@ -506,135 +483,43 @@ void MoonrakerPrinterAgent::build_ams_payload(int ams_count, int max_lane_index,
                }
            }

-            if (tray && tray->has_filament && slot_index < 32) {
-                tray_exist_bits |= (1UL << slot_index);
+            nlohmann::json tray_json = nlohmann::json::object();
+            tray_json["id"] = std::to_string(slot_id);
+            tray_json["tag_uid"] = "0000000000000000";
+
+            if (tray && tray->has_filament) {
+                tray_exist_bits |= (1 << slot_index);
+
+                tray_json["tray_info_idx"] = tray->tray_info_idx;
+                tray_json["tray_type"] = tray->tray_type;
+                tray_json["tray_color"] = normalize_color_value(tray->tray_color);
+
+                // Add temperature data if provided
+                if (tray->bed_temp > 0) {
+                    tray_json["bed_temp"] = std::to_string(tray->bed_temp);
+                }
+                if (tray->nozzle_temp > 0) {
+                    tray_json["nozzle_temp_max"] = std::to_string(tray->nozzle_temp);
+                }
+            } else {
+                tray_json["tray_info_idx"] = "";
+                tray_json["tray_type"] = "";
+                tray_json["tray_color"] = "00000000";
+                tray_json["tray_slot_placeholder"] = "1";
            }

-            static const AmsTrayData empty_tray;
-            tray_array.push_back(make_ams_tray_json(std::to_string(slot_id), tray ? *tray : empty_tray));
+            tray_array.push_back(tray_json);
        }
-
-        nlohmann::json ams_unit = nlohmann::json::object();
-        ams_unit["id"] = std::to_string(ams_id);
-        // Generic unit: type 1 (AMS) maps to AMSModel::GENERIC_AMS, which drives the
-        // variable-lane rendering. This is not a real Bambu AMS-Lite.
-        ams_unit["info"] = "0001";
        ams_unit["tray"] = tray_array;
        ams_array.push_back(ams_unit);
    }

-    BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::build_ams_payload: Parsed " << trays.size() << " trays";
-    submit_ams_payload(ams_array, ams_exist_bits, tray_exist_bits);
-}
-
-void MoonrakerPrinterAgent::build_ams_payload_grouped(const std::vector<AmsTrayData>& trays)
-{
-    // One AMS box per extruder, best effort. Lane-data changers (AFC, recent Happy Hare) report an
-    // extruder per lane but no physical box layout, so a box here is a logical feed group, not a
-    // discovered unit. Lanes without an extruder fall back to the main extruder.
-    std::map<int, std::vector<const AmsTrayData*>> boxes;
-    for (const auto& tray : trays) {
-        boxes[tray.extruder_id].push_back(&tray);
-    }
-
-    nlohmann::json ams_array = nlohmann::json::array();
-    unsigned long ams_exist_bits = 0;
-    unsigned long tray_exist_bits = 0;
-
-    int ams_id = 0;
-    // Cumulative lane index across all boxes, in box then slot order. A lane maps to exactly one
-    // extruder, so this is the lane's identity; the parser derives the same index for generic units.
-    int lane_index = 0;
-    for (auto& [extruder_id, lanes] : boxes) {
-        if (ams_id < 32) {
-            ams_exist_bits |= (1UL << ams_id);
-        }
-
-        // Keep a deterministic slot order within the box.
-        std::stable_sort(lanes.begin(), lanes.end(),
-                         [](const AmsTrayData* a, const AmsTrayData* b) { return a->slot_index < b->slot_index; });
-
-        nlohmann::json tray_array = nlohmann::json::array();
-        for (size_t slot = 0; slot < lanes.size(); ++slot) {
-            const AmsTrayData& tray = *lanes[slot];
-            // A logical feed group is not a four-slot Bambu AMS: the bit is the lane's cumulative
-            // index, not ams_id*4+slot. DevFilaSystemParser::ParseV1_0 reads the same index.
-            const int bit = lane_index++;
-            if (tray.has_filament && bit < 32) {
-                tray_exist_bits |= (1UL << bit);
-            }
-            tray_array.push_back(make_ams_tray_json(std::to_string(slot), tray));
-        }
-
-        nlohmann::json ams_unit = nlohmann::json::object();
-        ams_unit["id"] = std::to_string(ams_id);
-        // info: bits 0-3 = unit type (1 = AMS, i.e. AMSModel::GENERIC_AMS), bits 8-11 = bound
-        // extruder id. A logical feed group is a generic unit, not a Bambu AMS-Lite.
-        const int   info_val   = 1 | ((extruder_id & 0x0F) << 8);
-        const char* hex_digits = "0123456789ABCDEF";
-        std::string info       = "0000";
-        info[3] = hex_digits[info_val & 0x0F];
-        info[2] = hex_digits[(info_val >> 4) & 0x0F];
-        info[1] = hex_digits[(info_val >> 8) & 0x0F];
-        info[0] = hex_digits[(info_val >> 12) & 0x0F];
-        ams_unit["info"] = info;
-        ams_unit["tray"] = tray_array;
-        ams_array.push_back(ams_unit);
-        ++ams_id;
-    }
-
-    BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::build_ams_payload_grouped: Parsed " << trays.size()
-                            << " trays in " << boxes.size() << " extruder box(es)";
-    submit_ams_payload(ams_array, ams_exist_bits, tray_exist_bits);
-}
-
-nlohmann::json MoonrakerPrinterAgent::make_ams_tray_json(const std::string& tray_id, const AmsTrayData& tray)
-{
-    nlohmann::json tray_json = nlohmann::json::object();
-    tray_json["id"] = tray_id;
-    tray_json["tag_uid"] = "0000000000000000";
-
-    if (tray.has_filament) {
-        tray_json["tray_info_idx"] = tray.tray_info_idx;
-        tray_json["tray_type"] = tray.tray_type;
-        tray_json["tray_color"] = normalize_color_value(tray.tray_color);
-
-        // Add temperature data if provided
-        if (tray.bed_temp > 0) {
-            tray_json["bed_temp"] = std::to_string(tray.bed_temp);
-        }
-        if (tray.nozzle_temp > 0) {
-            tray_json["nozzle_temp_max"] = std::to_string(tray.nozzle_temp);
-        }
-    } else {
-        tray_json["tray_info_idx"] = "";
-        tray_json["tray_type"] = "";
-        tray_json["tray_color"] = "00000000";
-        tray_json["tray_slot_placeholder"] = "1";
-    }
-
-    return tray_json;
-}
-
-void MoonrakerPrinterAgent::submit_ams_payload(const nlohmann::json& ams_array, unsigned long ams_exist_bits, unsigned long tray_exist_bits)
-{
-    // Look up MachineObject via DeviceManager
-    auto* dev_manager = GUI::wxGetApp().getDeviceManager();
-    if (!dev_manager) {
-        return;
-    }
-    MachineObject* obj = dev_manager->get_my_machine(device_info.dev_id);
-    if (!obj) {
-        return;
-    }
-
    // Format as hex strings (matching BBL protocol)
    std::ostringstream ams_exist_ss;
    ams_exist_ss << std::hex << std::uppercase << ams_exist_bits;
    std::ostringstream tray_exist_ss;
    tray_exist_ss << std::hex << std::uppercase << tray_exist_bits;

-    nlohmann::json ams_json = nlohmann::json::object();
    ams_json["ams"] = ams_array;
    ams_json["ams_exist_bits"] = ams_exist_ss.str();
    ams_json["tray_exist_bits"] = tray_exist_ss.str();
@@ -645,6 +530,7 @@ void MoonrakerPrinterAgent::submit_ams_payload(const nlohmann::json& ams_array,

    // Call the parser to populate DevFilaSystem
    DevFilaSystemParser::ParseV1_0(print_json, obj, obj->GetFilaSystem().get(), false);
+    BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::build_ams_payload: Parsed " << trays.size() << " trays";

    // Set printer_type so update_sync_status() can match it against the preset's printer type.
    // Without this, the comparison fails and all sync badges are cleared.
@@ -684,15 +570,17 @@ bool MoonrakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSync
    if (fetch_moonraker_filament_data(trays, max_lane_index)) {
        BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::fetch_filament_info: Detected Moonraker filament system with "
                                << (max_lane_index + 1) << " lanes";
-        build_ams_payload_grouped(trays);
+        int ams_count = (max_lane_index + 4) / 4;
+        build_ams_payload(ams_count, max_lane_index, trays);
        return true;
    }

-    // Fall back to the Happy Hare `mmu` object for HH builds that do not publish lane_data
+    // Attempt Happy Hare first (more widely adopted, supports more filament changers)
    if (fetch_hh_filament_info(trays, max_lane_index)) {
        BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::fetch_filament_info: Detected Happy Hare MMU with "
                                << (max_lane_index + 1) << " gates";
-        build_ams_payload_grouped(trays);
+        int ams_count = (max_lane_index + 4) / 4;
+        build_ams_payload(ams_count, max_lane_index, trays);
        return true;
    }

@@ -798,30 +686,6 @@ int MoonrakerPrinterAgent::safe_json_int(const nlohmann::json& obj, const char*
    return 0;
 }

-int MoonrakerPrinterAgent::safe_json_int_flexible(const nlohmann::json& obj, const char* key, int default_value)
-{
-    auto it = obj.find(key);
-    if (it == obj.end())
-        return default_value;
-    if (it->is_number_integer())
-        return it->get<int>();
-    if (it->is_string()) {
-        const std::string s = it->get<std::string>();
-        if (s.empty())
-            return default_value;
-        try {
-            std::size_t consumed = 0;
-            const int   value    = std::stoi(s, &consumed);
-            if (consumed != s.size()) // reject partial parses such as "2oops"
-                return default_value;
-            return value;
-        } catch (...) {
-            return default_value;
-        }
-    }
-    return default_value;
-}
-
 std::string MoonrakerPrinterAgent::safe_array_string(const nlohmann::json& arr, int idx)
 {
    if (arr.is_array() && idx >= 0 && idx < static_cast<int>(arr.size()) && arr[idx].is_string())
@@ -925,39 +789,28 @@ bool MoonrakerPrinterAgent::fetch_moonraker_filament_data(std::vector<AmsTrayDat
    trays.clear();
    max_lane_index = 0;

-    // The lane_data namespace carries no extruder field; read the lane -> toolhead binding from the
-    // AFC printer objects so lanes on different toolheads end up in different AMS boxes.
-    std::map<std::string, int> lane_extruder;
-    fetch_afc_lane_extruders(lane_extruder);
-
    for (const auto& [lane_key, lane_obj] : value.items()) {
        if (!lane_obj.is_object()) {
            continue;
        }

-        // Lane tool number (0-based). AFC reports it as a string in the documented sample but it
-        // can also be a number; accept either and skip lanes without a usable index. Databases
-        // written without a "lane" field fall back to the key, which names the lane either as
-        // "T<N>" (0-based) or as "lane<N>" (1-based).
-        int lane_index = safe_json_int_flexible(lane_obj, "lane", -1);
-        if (lane_index < 0) {
-            lane_index = lane_index_from_key(lane_key);
-            if (lane_index < 0) {
-                continue;
+        // Extract lane index from the "lane" field (tool number, 0-based)
+        std::string lane_str = safe_json_string(lane_obj, "lane");
+        int lane_index = -1;
+        if (!lane_str.empty()) {
+            try {
+                lane_index = std::stoi(lane_str);
+            } catch (...) {
+                lane_index = -1;
            }
        }

+        if (lane_index < 0) {
+            continue;
+        }
+
        AmsTrayData tray;
        tray.slot_index = lane_index;
-        // AFC exposes the lane's extruder/toolhead as "extruder_index"; tolerate "extruder_id" as
-        // an alias. lane_data has neither, so fall back to the AFC lane objects and only then to
-        // the main extruder (best effort).
-        tray.extruder_id = safe_json_int_flexible(lane_obj, "extruder_index",
-                              safe_json_int_flexible(lane_obj, "extruder_id", -1));
-        if (tray.extruder_id < 0) {
-            const auto it = lane_extruder.find(lane_key);
-            tray.extruder_id = it != lane_extruder.end() ? it->second : 0;
-        }
        tray.tray_color = safe_json_string(lane_obj, "color");
        tray.tray_type = safe_json_string(lane_obj, "material");
        tray.bed_temp = safe_json_int(lane_obj, "bed_temp");
@@ -1062,121 +915,52 @@ bool MoonrakerPrinterAgent::fetch_hh_filament_info(std::vector<AmsTrayData>& tra
        return false;
    }

-    // Parse gate data. Every gate becomes a lane so empty/unknown gates surface
-    // as empty AMS slots rather than vanishing. HH is single-extruder, so all
-    // lanes belong to feed group 0.
+    // Parse gate data
    trays.clear();
+    max_lane_index = 0;

    for (int gate_idx = 0; gate_idx < num_gates; ++gate_idx) {
        // Check gate_status: -1 = unknown, 0 = empty, 1 or 2 = available
        int status = safe_array_int(gate_status, gate_idx);
+        if (status <= 0) {
+            continue;  // Skip unknown or empty gates
+        }
+
+        // Extract gate data
        std::string material = safe_array_string(gate_material, gate_idx);
        std::string color = safe_array_string(gate_color, gate_idx);
        int nozzle_temp = safe_array_int(gate_temperature, gate_idx);

-        AmsTrayData tray;
-        tray.slot_index = gate_idx;
-        tray.extruder_id = 0;
-
-        if (status > 0 && !material.empty()) {
-            tray.tray_type = material;
-            tray.tray_color = color;
-            tray.nozzle_temp = nozzle_temp;
-            tray.bed_temp = 0;  // HH doesn't provide bed temp in gate arrays
-            tray.has_filament = true;
-
-            auto* bundle = GUI::wxGetApp().preset_bundle;
-            tray.tray_info_idx = bundle
-                ? bundle->filaments.filament_id_by_type(tray.tray_type)
-                : map_filament_type_to_generic_id(tray.tray_type);
-        } else {
-            tray.has_filament = false;
+        // Skip if no material type (empty gate)
+        if (material.empty()) {
+            continue;
        }

+        AmsTrayData tray;
+        tray.slot_index = gate_idx;
+        tray.tray_type = material;
+        tray.tray_color = color;
+        tray.nozzle_temp = nozzle_temp;
+        tray.bed_temp = 0;  // HH doesn't provide bed temp in gate arrays
+        tray.has_filament = true;
+
+        auto* bundle = GUI::wxGetApp().preset_bundle;
+        tray.tray_info_idx = bundle
+            ? bundle->filaments.filament_id_by_type(tray.tray_type)
+            : map_filament_type_to_generic_id(tray.tray_type);
+
+        max_lane_index = std::max(max_lane_index, gate_idx);
        trays.push_back(tray);
    }

-    max_lane_index = num_gates - 1;
+    if (trays.empty()) {
+        BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::fetch_hh_filament_info: No valid HH gates found";
+        return false;
+    }

    return true;
 }

-// AFC writes its filament data into the lane_data database namespace, and the records of the
-// fixture/agent write path carry no extruder field, so the lane -> toolhead binding has to be read
-// from the printer objects: each AFC_lane <name>.extruder names the toolhead its lane feeds, and
-// the toolhead's name carries its own index. Best effort: on failure every lane keeps the fallback
-// of the main extruder.
-bool MoonrakerPrinterAgent::fetch_afc_lane_extruders(std::map<std::string, int>& lane_extruder)
-{
-    auto query_objects = [this](const std::string& query_string, nlohmann::json& out) {
-        auto http = Http::get(join_url(device_info.base_url, "/printer/objects/query?" + query_string));
-        if (!device_info.api_key.empty()) {
-            http.header("X-Api-Key", device_info.api_key);
-        }
-        std::string body;
-        unsigned    status_code = 0;
-        http.timeout_connect(5)
-            .timeout_max(10)
-            .on_complete([&](std::string response, unsigned status) {
-                body        = std::move(response);
-                status_code = status;
-            })
-            .perform_sync();
-        if (status_code != 200) {
-            return false;
-        }
-        out = nlohmann::json::parse(body, nullptr, false, true);
-        return !out.is_discarded();
-    };
-
-    nlohmann::json afc_json;
-    if (!query_objects("AFC", afc_json) || !afc_json.contains("result") ||
-        !afc_json["result"].contains("status") || !afc_json["result"]["status"].contains("AFC")) {
-        return false;
-    }
-
-    const auto& afc   = afc_json["result"]["status"]["AFC"];
-    const auto& lanes = afc.contains("lanes") ? afc["lanes"] : nlohmann::json::array();
-    if (!lanes.is_array() || lanes.empty()) {
-        return false;
-    }
-
-    // Query every lane object in one request; the object names are "AFC_lane <lane name>".
-    std::string query_string;
-    for (const auto& lane : lanes) {
-        if (!lane.is_string()) {
-            return false;
-        }
-        if (!query_string.empty()) {
-            query_string += "&";
-        }
-        query_string += "AFC_lane%20" + lane.get<std::string>();
-    }
-
-    nlohmann::json lanes_json;
-    if (!query_objects(query_string, lanes_json) || !lanes_json.contains("result") ||
-        !lanes_json["result"].contains("status")) {
-        return false;
-    }
-
-    const auto& status = lanes_json["result"]["status"];
-    for (const auto& lane : lanes) {
-        const std::string name = lane.get<std::string>();
-        const std::string key  = "AFC_lane " + name;
-        if (!status.contains(key) || !status[key].is_object() || !status[key].contains("extruder") ||
-            !status[key]["extruder"].is_string()) {
-            continue;
-        }
-        const std::string toolhead = status[key]["extruder"].get<std::string>();
-        const int toolhead_index   = extruder_index_from_name(toolhead);
-        if (toolhead_index >= 0) {
-            lane_extruder[name] = toolhead_index;
-        }
-    }
-
-    return !lane_extruder.empty();
-}
-
 int MoonrakerPrinterAgent::handle_request(const std::string& dev_id, const std::string& json_str)
 {
    auto json = nlohmann::json::parse(json_str, nullptr, false);
@@ -1275,25 +1059,6 @@ int MoonrakerPrinterAgent::handle_request(const std::string& dev_id, const std::
            }
        }

-        // Tool selection is printer-specific G-code. Moonraker forwards the
-        // conventional T<index> command to Klipper, where the printer can
-        // implement logical selection or a physical toolhead attach macro.
-        if (cmd == "select_extruder") {
-            if (!json["print"].contains("extruder_index") || !json["print"]["extruder_index"].is_number_integer()) {
-                BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: select_extruder missing integer extruder_index, full json: " << json_str;
-                return BAMBU_NETWORK_ERR_INVALID_RESULT;
-            }
-
-            const int extruder_idx = json["print"]["extruder_index"].get<int>();
-            if (extruder_idx < 0) {
-                BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: select_extruder received negative extruder_index: " << extruder_idx;
-                return BAMBU_NETWORK_ERR_INVALID_RESULT;
-            }
-
-            send_gcode_async(dev_id, "T" + std::to_string(extruder_idx));
-            return BAMBU_NETWORK_SUCCESS;
-        }
-
        if (cmd == "home") {
            send_gcode_async(dev_id, "G28");
            return BAMBU_NETWORK_SUCCESS;
@@ -1390,7 +1155,7 @@ bool MoonrakerPrinterAgent::query_printer_status(const std::string& base_url,
                                                 nlohmann::json&    status,
                                                 std::string&       error) const
 {
-    std::string url = join_url(base_url, "/printer/objects/query?print_stats&virtual_sdcard&toolhead&extruder&heater_bed&fan");
+    std::string url = join_url(base_url, "/printer/objects/query?print_stats&virtual_sdcard&extruder&heater_bed&fan");

    std::string response_body;
    bool        success = false;
@@ -1798,12 +1563,11 @@ void MoonrakerPrinterAgent::run_status_stream(std::string dev_id, std::string ba
                }

                for (const auto& name : this->available_objects) {
-                    const bool is_main_extruder = name == "extruder";
-                    const bool is_additional_extruder =
-                        name.rfind("extruder", 0) == 0 && name.size() > 8 &&
-                        std::all_of(name.begin() + 8, name.end(), [](unsigned char c) { return std::isdigit(c) != 0; });
-                    if (is_main_extruder || is_additional_extruder) {
+                    if (name == "extruder" || name.rfind("extruder", 0) == 0) {
                        subscribe_objects.insert(name);
+                        if (name == "extruder") {
+                            break;
+                        }
                    }
                }
            } else {
@@ -2099,81 +1863,6 @@ nlohmann::json MoonrakerPrinterAgent::build_print_payload_locked() const
        }
    }

-    // MachineObject::parse_new_info() only parses device.extruder when the four
-    // legacy new-protocol fields are present. Moonraker has no equivalents, so
-    // empty values act as compatibility markers without enabling any features.
-    std::map<int, const nlohmann::json*> extruder_status;
-    for (const auto& item : status_cache.items()) {
-        int extruder_id = -1;
-        if (item.key() == "extruder") {
-            extruder_id = 0;
-        } else if (item.key().rfind("extruder", 0) == 0 && item.key().size() > 8 &&
-                   std::all_of(item.key().begin() + 8, item.key().end(), [](unsigned char c) { return std::isdigit(c) != 0; })) {
-            try {
-                extruder_id = std::stoi(item.key().substr(8));
-            } catch (...) {
-                extruder_id = -1;
-            }
-        }
-        if (extruder_id >= 0 && item.value().is_object()) {
-            extruder_status.emplace(extruder_id, &item.value());
-        }
-    }
-
-    if (!extruder_status.empty()) {
-        auto& device_extruder = payload["print"]["device"]["extruder"];
-
-        int current_extruder_id = 0;
-        if (status_cache.contains("toolhead") && status_cache["toolhead"].is_object() &&
-            status_cache["toolhead"].contains("extruder") && status_cache["toolhead"]["extruder"].is_string()) {
-            const std::string active_extruder = status_cache["toolhead"]["extruder"].get<std::string>();
-            if (active_extruder != "extruder" && active_extruder.rfind("extruder", 0) == 0 && active_extruder.size() > 8 &&
-                std::all_of(active_extruder.begin() + 8, active_extruder.end(), [](unsigned char c) { return std::isdigit(c) != 0; })) {
-                try {
-                    const int parsed_id = std::stoi(active_extruder.substr(8));
-                    if (parsed_id >= 0 && parsed_id < 16 && extruder_status.count(parsed_id) != 0) {
-                        current_extruder_id = parsed_id;
-                    }
-                } catch (...) {
-                    // Keep the main extruder as the fallback for malformed status data.
-                }
-            }
-        }
-
-        const int extruder_count = std::min<int>(static_cast<int>(extruder_status.size()), 0xF);
-        device_extruder["state"] = extruder_count | (current_extruder_id << 4);
-        device_extruder["info"] = nlohmann::json::array();
-
-        auto encoded_temperature = [](const nlohmann::json& status, const char* key) {
-            if (!status.contains(key) || !status[key].is_number()) {
-                return 0;
-            }
-            const double temperature = status[key].get<double>();
-            return std::clamp(static_cast<int>(temperature + 0.5), 0, 65535);
-        };
-
-        for (const auto& [extruder_id, status] : extruder_status) {
-            const int current_temperature = encoded_temperature(*status, "temperature");
-            const int target_temperature  = encoded_temperature(*status, "target");
-            device_extruder["info"].push_back({
-                {"id", extruder_id},
-                {"filam_bak", nlohmann::json::array()},
-                {"info", 1 << 3}, // The configured Moonraker extruder has a toolhead.
-                {"temp", current_temperature | (target_temperature << 16)},
-                {"spre", 0},
-                {"snow", 0},
-                {"star", 0},
-                {"stat", 0},
-                {"hnow", 0},
-            });
-        }
-
-        payload["print"]["cfg"]  = "";
-        payload["print"]["fun"]  = "";
-        payload["print"]["aux"]  = "";
-        payload["print"]["stat"] = "";
-    }
-
    if (status_cache.contains("heater_bed") && status_cache["heater_bed"].is_object()) {
        const auto& bed = status_cache["heater_bed"];
        if (bed.contains("temperature") && bed["temperature"].is_number()) {
@@ -7,7 +7,6 @@
 #include <functional>
 #include <cstdint>
 #include <atomic>
-#include <map>
 #include <memory>
 #include <mutex>
 #include <set>
@@ -89,7 +88,6 @@ protected:
    // Tray data for AMS payload building
    struct AmsTrayData {
        int         slot_index = 0;      // 0-based slot index
-        int         extruder_id = 0;     // Extruder this lane feeds (AFC extruder_index); 0 when unknown
        bool        has_filament = false;
        std::string tray_type;           // Material type (e.g., "PLA", "ASA")
        std::string tray_color;          // Raw color (#RRGGBB, 0xRRGGBB, or RRGGBBAA)
@@ -101,10 +99,6 @@ protected:
    // Build ams JSON and call parser
    void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays);

-    // Build ams JSON with one box per extruder (best effort, for lane_data-based filament
-    // changers such as AFC) and call the parser. Boxes are ordered by extruder id.
-    void build_ams_payload_grouped(const std::vector<AmsTrayData>& trays);
-
    // Methods that derived classes may need to override or access
    virtual bool init_device_info(const std::string& dev_id, const std::string& dev_ip, const std::string& username, const std::string& password, bool use_ssl, const std::string& port);
    virtual bool fetch_device_info(const std::string& base_url, const std::string& api_key, MoonrakerDeviceInfo& info, std::string& error) const;
@@ -169,22 +163,10 @@ private:
    // System-specific filament fetch methods
    bool fetch_hh_filament_info(std::vector<AmsTrayData>& trays, int& max_lane_index);
    bool fetch_moonraker_filament_data(std::vector<AmsTrayData>& trays, int& max_lane_index);
-    // Lane name -> toolhead index, read from the AFC printer objects (the lane_data database has no
-    // extruder field). Returns false when AFC is not present or the objects cannot be read.
-    bool fetch_afc_lane_extruders(std::map<std::string, int>& lane_extruder);
-
-    // Build one BBL tray JSON object (placeholder when the tray has no filament).
-    static nlohmann::json make_ams_tray_json(const std::string& tray_id, const AmsTrayData& tray);
-
-    // Wrap the AMS boxes into the payload ParseV1_0 understands and apply the pull-mode
-    // readiness state (printer_type, push counters, storage, module versions).
-    void submit_ams_payload(const nlohmann::json& ams_array, unsigned long ams_exist_bits, unsigned long tray_exist_bits);

    // JSON helper methods
    static std::string safe_json_string(const nlohmann::json& obj, const char* key);
    static int safe_json_int(const nlohmann::json& obj, const char* key);
-    // Accepts either a JSON number or a numeric string (AFC reports some fields as strings).
-    static int safe_json_int_flexible(const nlohmann::json& obj, const char* key, int default_value);
    static std::string safe_array_string(const nlohmann::json& arr, int idx);
    static int safe_array_int(const nlohmann::json& arr, int idx);
    static std::string normalize_color_value(const std::string& color);
@@ -30,6 +30,7 @@
 #include "libslic3r/Line.hpp"
 #include "libslic3r/ExtrusionEntity.hpp"
 #include "libslic3r/BoundingBox.hpp"
+#include <functional>
 #include <map>
 #include <set>
 #include <string>
@@ -596,3 +597,127 @@ TEST_CASE("Body centering survives islands merging and splitting between layers"
        }
    }
 }
+
+TEST_CASE("Z contouring slices an object that has several instances", "[PrintObject]")
+{
+    Print print;
+    Model model;
+    place_two_cube_instances_apart(10., { { "zaa_enabled", "1" } }, print, model);
+    REQUIRE(print.objects().size() == 1);
+    REQUIRE(print.objects().front()->instances().size() == 2);
+
+    CHECK_NOTHROW(print.process());
+    CHECK(print.objects().front()->is_step_done(posContouring));
+}
+
+TEST_CASE("Z contouring slices instances of one object that are turned differently", "[PrintObject]")
+{
+    // An instance turned about Z is sliced as a PrintObject of its own, with the same ModelObject behind it.
+    Print print;
+    Model model;
+    place_two_cube_instances_apart(10., { { "zaa_enabled", "1" } }, print, model);
+    model.objects.front()->instances.back()->set_rotation(Z, PI / 4.);
+    print.apply(model, DynamicPrintConfig(print.full_print_config()));
+    REQUIRE(print.objects().size() == 2);
+
+    CHECK_NOTHROW(print.process());
+    for (const PrintObject *object : print.objects())
+        CHECK(object->is_step_done(posContouring));
+}
+
+// A box tilted about X, so that its top slopes along Y and Z contouring has a surface to follow, with
+// one instance for each Z rotation given, laid out in a row.
+static void slice_tilted_box_instances(const std::vector<double> &z_rotations, Print &print, Model &model)
+{
+    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+    config.set_deserialize_strict({ { "zaa_enabled", "1" } });
+
+    TriangleMesh box = make_cube(20, 20, 10);
+    box.rotate_x(float(PI / 12.));
+    ModelObject *object = model.add_object();
+    object->add_volume(std::move(box));
+    for (size_t idx = 0; idx < z_rotations.size(); ++idx) {
+        ModelInstance *instance = object->add_instance();
+        instance->set_offset(Vec3d(50. + 50. * double(idx), 100., 0.));
+        instance->set_rotation(Z, z_rotations[idx]);
+    }
+    object->ensure_on_bed();
+    print.auto_assign_extruders(object);
+    print.apply(model, config);
+    print.validate();
+    print.set_status_silent();
+    print.process();
+}
+
+// The Z that contouring gave each point of the object's extrusions, by layer and by XY in the
+// PrintObject's own frame, which does not depend on where its instances stand on the bed.
+static std::vector<std::map<std::pair<coord_t, coord_t>, coord_t>> contoured_heights(const PrintObject &object)
+{
+    std::vector<std::map<std::pair<coord_t, coord_t>, coord_t>> heights(object.layer_count());
+    for (size_t layer_idx = 0; layer_idx < object.layer_count(); ++layer_idx) {
+        auto &layer_heights = heights[layer_idx];
+        std::function<void(const ExtrusionEntity &)> visit = [&](const ExtrusionEntity &entity) {
+            if (const auto *path = dynamic_cast<const ExtrusionPath *>(&entity)) {
+                if (path->z_contoured)
+                    for (const Point3 &pt : path->polyline.points)
+                        layer_heights[{ pt.x(), pt.y() }] = pt.z();
+            } else if (const auto *multipath = dynamic_cast<const ExtrusionMultiPath *>(&entity)) {
+                for (const ExtrusionPath &path : multipath->paths)
+                    visit(path);
+            } else if (const auto *loop = dynamic_cast<const ExtrusionLoop *>(&entity)) {
+                for (const ExtrusionPath &path : loop->paths)
+                    visit(path);
+            } else if (const auto *collection = dynamic_cast<const ExtrusionEntityCollection *>(&entity)) {
+                for (const ExtrusionEntity *child : collection->entities)
+                    visit(*child);
+            }
+        };
+        for (const LayerRegion *region : object.get_layer(int(layer_idx))->regions()) {
+            visit(region->perimeters);
+            visit(region->fills);
+        }
+    }
+    return heights;
+}
+
+TEST_CASE("Z contouring follows the surface of each instance as it is turned", "[PrintObject]")
+{
+    // Two instances of a box with a sloped top, the second turned a quarter turn about Z: its top slopes
+    // along X instead of Y. Each is contoured against the box turned as that instance is, so it has to
+    // match the same box placed alone with that turn.
+    Print print;
+    Model model;
+    slice_tilted_box_instances({ 0., PI / 2. }, print, model);
+    REQUIRE(print.objects().size() == 2);
+
+    for (const PrintObject *object : print.objects()) {
+        const double z_rotation = object->instances().front().model_instance->get_rotation().z();
+        Print reference;
+        Model reference_model;
+        slice_tilted_box_instances({ z_rotation }, reference, reference_model);
+        REQUIRE(reference.objects().size() == 1);
+
+        const auto heights           = contoured_heights(*object);
+        const auto reference_heights = contoured_heights(*reference.objects().front());
+        REQUIRE(heights.size() == reference_heights.size());
+
+        size_t matched = 0, lifted = 0;
+        for (size_t layer_idx = 0; layer_idx < heights.size(); ++layer_idx) {
+            const coord_t print_z = scaled(object->get_layer(int(layer_idx))->print_z);
+            for (const auto &[xy, z] : heights[layer_idx]) {
+                const auto it = reference_heights[layer_idx].find(xy);
+                if (it == reference_heights[layer_idx].end())
+                    continue;
+                INFO("layer " << layer_idx << ", rotation " << z_rotation);
+                CHECK(std::abs(z - it->second) <= scaled(0.001));
+                ++matched;
+                if (std::abs(z - print_z) > scaled(0.01))
+                    ++lifted;
+            }
+        }
+        INFO("rotation " << z_rotation);
+        // Enough points in common to mean something, and contouring did move some of them.
+        CHECK(matched > 100);
+        CHECK(lifted > 0);
+    }
+}
@@ -5,7 +5,6 @@ add_executable(${_TEST_NAME}_tests
    test_config_value_formatter.cpp
    test_creality_cfs_match.cpp
    test_dev_mapping.cpp
-    test_dev_extder_system.cpp
    test_device_access.cpp
    test_moonraker_discovery.cpp
    test_network_discovery.cpp
@@ -1,161 +0,0 @@
-// Match the include environment that libslic3r_gui TUs get from pchheader.hpp: Windows.h with
-// WIN32_LEAN_AND_MEAN/NOMINMAX must come first so rpcndr.h's `byte` is processed before <cstddef>
-// makes std::byte a competing candidate (otherwise the Windows COM headers pulled in via
-// DeviceManager.hpp error with an ambiguous `byte`). wx/timer.h must precede DeviceManager.hpp,
-// which includes DeviceErrorDialog.hpp (uses wxTimerEvent) before its own wx/timer.h include.
-#include "catch2/catch_test_macros.hpp"
-#include "catch2/catch_message.hpp"
-#include <slic3r/GUI/DeviceCore/DevDefs.h>
-#include <string>
-#include <utility>
-#include <vector>
-#ifdef WIN32
-    #ifndef WIN32_LEAN_AND_MEAN
-        #define WIN32_LEAN_AND_MEAN
-    #endif
-    #ifndef NOMINMAX
-        #define NOMINMAX
-    #endif
-    #include <Windows.h>
-#endif
-
-#include <catch2/catch_all.hpp>
-
-#include <wx/timer.h>
-
-#include "slic3r/GUI/DeviceManager.hpp"
-#include "slic3r/GUI/DeviceCore/DevExtruderSystem.h"
-
-#include <nlohmann/json.hpp>
-
-using json = nlohmann::json;
-using namespace Slic3r;
-
-TEST_CASE("Extruder state decodes a generic toolhead set", "[DevExtderSystem]")
-{
-    MachineObject obj(nullptr, nullptr, "test", "test_dev", "127.0.0.1");
-
-    // device.extruder.state packing: count 0..3, current 4..7, target 8..11,
-    // switch 12..14, loading 15..18, busy 19.
-    const int extruder_count   = 4;
-    const int current_extruder = 2;
-    const int switch_state     = ES_BUSY;
-    const int loading_extruder = 1;
-    const int state = extruder_count | (current_extruder << 4) | (3 << 8) |
-                      (switch_state << 12) | (loading_extruder << 15) | (1 << 19);
-
-    json extruder = { {"state", state}, {"info", json::array()} };
-    for (int id = 0; id < extruder_count; ++id) {
-        // info: bit 1 has filament, bit 3 nozzle present.
-        // temp: current 0..15, target 16..31. spre/snow/star: slot 0..7, ams 8..15.
-        extruder["info"].push_back({
-            {"id", id},
-            {"filam_bak", json::array({id})},
-            {"info", (id % 2 == 0 ? 2 : 0) | 8},
-            {"temp", (200 + id) | ((250 + id) << 16)},
-            {"spre", 10 << 8},
-            {"snow", id | ((20 + id) << 8)},
-            {"star", 30 << 8},
-            {"stat", 0},
-            {"hnow", id},
-        });
-    }
-
-    ExtderSystemParser::ParseV2_0(extruder, obj.GetExtderSystem());
-
-    REQUIRE(obj.GetExtderSystem()->GetTotalExtderCount() == extruder_count);
-    CHECK(obj.GetExtderSystem()->GetCurrentExtderId() == current_extruder);
-    CHECK(static_cast<int>(obj.GetExtderSystem()->GetSwitchState()) == switch_state);
-    CHECK(obj.GetExtderSystem()->GetLoadingExtderId() == loading_extruder);
-    CHECK(obj.GetExtderSystem()->IsBusyLoading());
-
-    for (int id = 0; id < extruder_count; ++id) {
-        const auto ext = obj.GetExtderSystem()->GetExtderById(id);
-        REQUIRE(ext.has_value());
-        INFO("extruder " << id);
-        CHECK(ext->GetExtId() == id);
-        CHECK(ext->GetCurrentTemp() == 200 + id);
-        CHECK(ext->GetTargetTemp() == 250 + id);
-        CHECK(ext->HasFilamentInExt() == (id % 2 == 0));
-        CHECK(ext->GetFilamBackup() == std::vector<int>{id});
-        CHECK(ext->GetSlotPre().ams_id == "10");
-        CHECK(ext->GetSlotNow().ams_id == std::to_string(20 + id));
-        CHECK(ext->GetSlotNow().slot_id == std::to_string(id));
-        CHECK(ext->GetSlotTarget().ams_id == "30");
-        CHECK(ext->GetNozzleId() == id);
-    }
-}
-
-TEST_CASE("Legacy single-toolhead parser fills only the main extruder", "[DevExtderSystem]")
-{
-    MachineObject obj(nullptr, nullptr, "test", "test_dev", "127.0.0.1");
-    REQUIRE(obj.GetExtderSystem()->GetTotalExtderCount() == 1);
-
-    // ParseV1_0 is the legacy single/dual fallback. It returns unless the system reports exactly
-    // one toolhead, so it only ever writes MAIN_EXTRUDER_ID's fields.
-    const json legacy = {
-        {"nozzle_temper", 210},
-        {"nozzle_target_temper", 245},
-        {"ams", {{"tray_now", "2"}, {"tray_tar", "3"}}}
-    };
-    ExtderSystemParser::ParseV1_0(legacy, obj.GetExtderSystem());
-
-    const auto ext = obj.GetExtderSystem()->GetExtderById(MAIN_EXTRUDER_ID);
-    REQUIRE(ext.has_value());
-    CHECK(ext->GetCurrentTemp() == 210);
-    CHECK(ext->GetTargetTemp() == 245);
-
-    // Below 0x80 the tray pointer encodes ams_id = value / 4, slot_id = value % 4.
-    CHECK(ext->GetSlotNow().ams_id == "0");
-    CHECK(ext->GetSlotNow().slot_id == "2");
-    CHECK(ext->GetSlotTarget().ams_id == "0");
-    CHECK(ext->GetSlotTarget().slot_id == "3");
-    CHECK(obj.GetExtderSystem()->IsBusyLoading());
-    CHECK(obj.GetExtderSystem()->GetLoadingExtderId() == MAIN_EXTRUDER_ID);
-}
-
-// ParseV2_0 does not enforce the documented extruder dialect invariants: the count in `state` and
-// the id ordering of `info[]` are trusted, not checked. This test pins the resulting behavior.
-TEST_CASE("Malformed extruder payload is stored by info array position", "[DevExtderSystem]")
-{
-    const auto extder_info = [](int id) {
-        // Every key ParseV2_0 reads must be present.
-        return json{ {"id", id}, {"filam_bak", json::array()}, {"info", 0}, {"temp", 0},
-                     {"spre", 0}, {"snow", 0}, {"star", 0}, {"stat", 0}, {"hnow", 0} };
-    };
-
-    SECTION("state count disagrees with info length") {
-        MachineObject obj(nullptr, nullptr, "test", "test_dev", "127.0.0.1");
-
-        // `state` reports 2 toolheads but info[] carries 3.
-        json info = json::array();
-        for (int id = 0; id < 3; ++id)
-            info.push_back(extder_info(id));
-        ExtderSystemParser::ParseV2_0(json{ {"state", 2}, {"info", info} }, obj.GetExtderSystem());
-
-        // The info array wins: three toolheads are stored. m_total_extder_count still holds 2, so
-        // GetTotalExtderCount() would trip its debug assert; only the stored vector is inspected.
-        CHECK(obj.GetExtderSystem()->GetTotalExtderSize() == 3);
-        for (int id = 0; id < 3; ++id) {
-            const auto ext = obj.GetExtderSystem()->GetExtderById(id);
-            REQUIRE(ext.has_value());
-            CHECK(ext->GetExtId() == id);
-        }
-    }
-
-    SECTION("info id differs from the array index") {
-        MachineObject obj(nullptr, nullptr, "test", "test_dev", "127.0.0.1");
-
-        // ids 1 and 2 sit at array positions 0 and 1.
-        json info = json::array({extder_info(1), extder_info(2)});
-        ExtderSystemParser::ParseV2_0(json{ {"state", 2}, {"info", info} }, obj.GetExtderSystem());
-
-        // Toolheads are stored by array position; the payload id is kept but is not the lookup key.
-        const auto first = obj.GetExtderSystem()->GetExtderById(0);
-        REQUIRE(first.has_value());
-        CHECK(first->GetExtId() == 1);
-        const auto second = obj.GetExtderSystem()->GetExtderById(1);
-        REQUIRE(second.has_value());
-        CHECK(second->GetExtId() == 2);
-    }
-}
@@ -13,14 +13,10 @@
    #include <Windows.h>
 #endif

-#include <set>
-#include <string>
-#include <utility>
-#include <vector>
-
 #include <catch2/catch_test_macros.hpp>
 #include "slic3r/GUI/DeviceCore/DevDefs.h"
 #include "libslic3r/ProjectTask.hpp"
+#include <vector>
 #include <catch2/catch_message.hpp>

 #include <catch2/catch_all.hpp>
@@ -69,162 +65,6 @@ TEST_CASE("AMS tray placeholder state follows the latest status", "[DevFilaSyste
    CHECK_FALSE(tray->is_slot_placeholder);
 }

-TEST_CASE("Agent filament slots preserve every extruder and AMS binding", "[DevFilaSystem]")
-{
-    MachineObject obj(nullptr, nullptr, "test", "test_dev", "127.0.0.1");
-
-    const json filament = json::parse(R"({
-        "units": [
-            { "id": "0", "extruder": 0, "slots": [
-                { "index": 0, "loaded": true, "material": "PLA", "color": "FF5733FF" },
-                { "index": 1, "loaded": true, "material": "PLA", "color": "33C1FFFF" },
-                { "index": 2, "loaded": true, "material": "PLA", "color": "8D33FFFF" },
-                { "index": 3, "loaded": false, "material": "",    "color": "00000000" }
-            ] },
-            { "id": "1", "extruder": 1, "slots": [
-                { "index": 0, "loaded": true, "material": "ASA", "color": "33C1FFFF" },
-                { "index": 1, "loaded": true, "material": "ASA", "color": "8D33FFFF" },
-                { "index": 2, "loaded": true, "material": "ASA", "color": "FF5733FF" },
-                { "index": 3, "loaded": false, "material": "",    "color": "00000000" }
-            ] },
-            { "id": "2", "extruder": 2, "slots": [
-                { "index": 0, "loaded": true, "material": "ABS", "color": "8D33FFFF" },
-                { "index": 1, "loaded": true, "material": "ABS", "color": "FF5733FF" },
-                { "index": 2, "loaded": true, "material": "ABS", "color": "33C1FFFF" },
-                { "index": 3, "loaded": false, "material": "",    "color": "00000000" }
-            ] },
-            { "id": "3", "extruder": 3, "slots": [
-                { "index": 0, "loaded": true, "material": "PETG", "color": "FF5733FF" },
-                { "index": 1, "loaded": true, "material": "PETG", "color": "33C1FFFF" },
-                { "index": 2, "loaded": true, "material": "PETG", "color": "8D33FFFF" },
-                { "index": 3, "loaded": false, "material": "",    "color": "00000000" }
-            ] }
-        ],
-        "external": [
-            { "extruder": 3, "loaded": true, "material": "PETG", "preset_id": "P3" },
-            { "extruder": 0, "loaded": true, "material": "PLA",  "preset_id": "P0" },
-            { "extruder": 2, "loaded": false, "material": "ABS", "preset_id": "P2" },
-            { "extruder": 1, "loaded": true, "material": "ASA",  "preset_id": "P1" }
-        ]
-    })");
-
-    DevFilaSystemParser::ParseAgentFilament(filament, &obj, obj.GetFilaSystem().get());
-
-    REQUIRE(obj.vt_slot.size() == 4);
-    CHECK(obj.vt_slot[0].id == "255");
-    CHECK(obj.vt_slot[1].id == "254");
-    CHECK(obj.vt_slot[2].id == "253");
-    CHECK(obj.vt_slot[3].id == "252");
-    CHECK(obj.vt_slot[0].setting_id == "P0");
-    CHECK(obj.vt_slot[1].setting_id == "P1");
-    CHECK(obj.vt_slot[2].setting_id == "P2");
-    CHECK(obj.vt_slot[3].setting_id == "P3");
-
-    REQUIRE(obj.GetFilaSystem()->GetAmsCount() == 4);
-    for (int extruder = 0; extruder < 4; ++extruder) {
-        const auto& ams = obj.GetFilaSystem()->GetAmsList().at(std::to_string(extruder));
-        CHECK(ams->GetExtruderId() == extruder);
-        CHECK(ams->GetBindedExtruderSet() == std::set<int>{extruder});
-        REQUIRE(ams->GetTrays().size() == 4);
-        CHECK(ams->GetTrays().at("0")->color != ams->GetTrays().at("1")->color);
-        CHECK(ams->GetTrays().at("1")->color != ams->GetTrays().at("2")->color);
-        CHECK_FALSE(ams->GetTrays().at("3")->is_exists);
-    }
-
-    CHECK(obj.contains_tray("253", "0"));
-    CHECK(obj.get_tray("253", "0").setting_id == "P2");
-    CHECK(obj.GetFilaSystem()->GetExtruderIdByAmsId("253") == 2);
-
-    const auto tray_index_map = obj.GetFilaSystem()->GetTrayIndexMap();
-    REQUIRE(tray_index_map.count(252) == 1);
-    CHECK(tray_index_map.at(252).first == 252);
-    CHECK(tray_index_map.at(252).second == 0);
-}
-
-TEST_CASE("Generic AMS tray index map uses cumulative lane counts", "[DevMapping]")
-{
-    MachineObject obj(nullptr, nullptr, "test", "test_dev", "127.0.0.1");
-
-    // A well-formed generic payload pairs "units" with "external". An empty external array resets
-    // vt_slot, clearing the default virtual tray (255) MachineObject's constructor seeds; otherwise
-    // that phantom external tray lands in GetTrayIndexMap and inflates the map size.
-    json filament = { {"units", json::array()}, {"external", json::array()} };
-    for (int ams_id = 0; ams_id < 2; ++ams_id) {
-        json unit = {
-            {"id", std::to_string(ams_id)},
-            {"extruder", ams_id},
-            {"slots", json::array()}
-        };
-        for (int slot_id = 0; slot_id < 5; ++slot_id)
-            unit["slots"].push_back({{"index", slot_id}, {"loaded", false}});
-        filament["units"].push_back(std::move(unit));
-    }
-
-    DevFilaSystemParser::ParseAgentFilament(filament, &obj, obj.GetFilaSystem().get());
-
-    const auto tray_index_map = obj.GetFilaSystem()->GetTrayIndexMap();
-    REQUIRE(tray_index_map.size() == 10);
-    CHECK(tray_index_map.at(0).first == 0);
-    CHECK(tray_index_map.at(0).second == 0);
-    CHECK(tray_index_map.at(4).first == 0);
-    CHECK(tray_index_map.at(4).second == 4);
-    CHECK(tray_index_map.at(5).first == 1);
-    CHECK(tray_index_map.at(5).second == 0);
-    CHECK(tray_index_map.at(9).first == 1);
-    CHECK(tray_index_map.at(9).second == 4);
-}
-
-TEST_CASE("Generic tray index map handles unequal per-unit slot counts", "[DevMapping]")
-{
-    MachineObject obj(nullptr, nullptr, "test", "test_dev", "127.0.0.1");
-
-    // An "external" array must accompany "units" so vt_slot is reset (see the cumulative test above).
-    json filament = { {"units", json::array()}, {"external", json::array()} };
-    const std::vector<int> slot_counts = {4, 12};
-    for (int ams_id = 0; ams_id < static_cast<int>(slot_counts.size()); ++ams_id) {
-        json unit = { {"id", std::to_string(ams_id)}, {"extruder", ams_id}, {"slots", json::array()} };
-        for (int slot_id = 0; slot_id < slot_counts[ams_id]; ++slot_id)
-            unit["slots"].push_back({{"index", slot_id}, {"loaded", false}});
-        filament["units"].push_back(std::move(unit));
-    }
-
-    DevFilaSystemParser::ParseAgentFilament(filament, &obj, obj.GetFilaSystem().get());
-
-    const auto tray_index_map = obj.GetFilaSystem()->GetTrayIndexMap();
-    REQUIRE(tray_index_map.size() == 16);
-    // Unit 0 occupies global lanes 0..3; unit 1 continues at 4..15 because the counter advances
-    // by the reported tray count, not by a fixed four-slot stride.
-    CHECK(tray_index_map.at(0).first == 0);
-    CHECK(tray_index_map.at(0).second == 0);
-    CHECK(tray_index_map.at(3).first == 0);
-    CHECK(tray_index_map.at(3).second == 3);
-    CHECK(tray_index_map.at(4).first == 1);
-    CHECK(tray_index_map.at(4).second == 0);
-    CHECK(tray_index_map.at(15).first == 1);
-    CHECK(tray_index_map.at(15).second == 11);
-}
-
-TEST_CASE("A generic AMS unit reports its reported tray count", "[DevFilaSystem]")
-{
-    MachineObject obj(nullptr, nullptr, "test", "test_dev", "127.0.0.1");
-
-    json filament = { {"units", json::array()}, {"external", json::array()} };
-    const std::vector<int> slot_counts = {8, 1};
-    for (int ams_id = 0; ams_id < static_cast<int>(slot_counts.size()); ++ams_id) {
-        json unit = { {"id", std::to_string(ams_id)}, {"extruder", ams_id}, {"slots", json::array()} };
-        for (int slot_id = 0; slot_id < slot_counts[ams_id]; ++slot_id)
-            unit["slots"].push_back({{"index", slot_id}, {"loaded", false}});
-        filament["units"].push_back(std::move(unit));
-    }
-
-    DevFilaSystemParser::ParseAgentFilament(filament, &obj, obj.GetFilaSystem().get());
-
-    // Non-Bambu units are not capped at the four-slot Bambu contract; the reported tray count wins.
-    const auto& ams_list = obj.GetFilaSystem()->GetAmsList();
-    REQUIRE(ams_list.at("0")->GetSlotCount() == 8);
-    REQUIRE(ams_list.at("1")->GetSlotCount() == 1);
-}
-
 TEST_CASE("Switch-bound AMS trays map to the left extruder", "[DevMapping]")
 {
    MachineObject obj(nullptr, nullptr, "test", "test_dev", "127.0.0.1");
@@ -1,5 +1,6 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/catch_all.hpp>
+#include <catch2/generators/catch_generators.hpp>

 #include <slic3r/GUI/DeviceCore/DevManager.h>
 #include <slic3r/GUI/DeviceManager.hpp>
@@ -16,6 +17,7 @@
 #include <cstdint>
 #include <string>
 #include <utility>
+#include <vector>

 using namespace Slic3r;
 using json = nlohmann::json;
@@ -49,6 +51,21 @@ public:

    AgentInfo get_agent_info() override { return m_info; }

+    int send_message(std::string dev_id, std::string json_str, int, int) override
+    {
+        published_device = std::move(dev_id);
+        published_message = json::parse(json_str);
+        return 0;
+    }
+
+    int send_message_to_printer(std::string dev_id, std::string json_str, int qos, int flag) override
+    {
+        return send_message(std::move(dev_id), std::move(json_str), qos, flag);
+    }
+
+    std::string published_device;
+    json published_message;
+
 private:
    AgentInfo m_info;
 };
@@ -160,3 +177,62 @@ TEST_CASE("Device manager filters and rehomes devices by printer-agent ownership
    CHECK(manager.get_my_machine_list("integration-agent-a").empty());
    CHECK(manager.get_my_machine_list("integration-agent-b").count(machine.dev_id) == 1);
 }
+
+TEST_CASE("AMS filament settings keep legacy single-color commands compatible", "[DeviceManager][AMSMaterialsSetting][integration]")
+{
+    ScopedAppConfig app_config;
+    auto agent = std::make_shared<TestPrinterAgent>("integration-agent");
+    NetworkAgent network(nullptr, agent);
+    DeviceManager manager(&network, false, &app_config.config);
+    MachineObject object(&manager, &network, "Test printer", "integration-device", "192.0.2.10");
+    object.dev_connection_type = GENERATE("lan", "cloud");
+
+    REQUIRE(object.command_ams_filament_settings(1, 2, "filament-id", "setting-id", "FF000080", "PLA", 190, 220) == 0);
+
+    const json& payload = agent->published_message.at("print");
+    CHECK(agent->published_device == object.get_dev_id());
+    CHECK(payload.at("command") == "ams_filament_setting");
+    CHECK(payload.at("ams_id") == 1);
+    CHECK(payload.at("slot_id") == 2);
+    CHECK(payload.at("tray_color") == "FF000080");
+    CHECK_FALSE(payload.contains("cols"));
+    CHECK_FALSE(payload.contains("ctype"));
+}
+
+TEST_CASE("AMS filament settings preserve ordered gradient and multicolor RGBA components", "[DeviceManager][AMSMaterialsSetting][integration]")
+{
+    ScopedAppConfig app_config;
+    auto agent = std::make_shared<TestPrinterAgent>("integration-agent");
+    NetworkAgent network(nullptr, agent);
+    DeviceManager manager(&network, false, &app_config.config);
+    MachineObject object(&manager, &network, "Test printer", "integration-device", "192.0.2.10");
+    object.dev_connection_type = GENERATE("lan", "cloud");
+    const int color_type = GENERATE(0, 1);
+    const std::vector<std::string> colors{"FF000080", "0000FF40", "00FF00FF"};
+
+    REQUIRE(object.command_ams_filament_settings(1, 2, "filament-id", "setting-id", colors.front(), "PLA", 190, 220,
+                                                 colors, color_type) == 0);
+
+    const json& payload = agent->published_message.at("print");
+    CHECK(payload.at("tray_color") == colors.front());
+    CHECK(payload.at("cols").get<std::vector<std::string>>() == colors);
+    CHECK(payload.at("ctype") == color_type);
+}
+
+TEST_CASE("AMS filament settings default a supplied single-color list to type two", "[DeviceManager][AMSMaterialsSetting][integration]")
+{
+    ScopedAppConfig app_config;
+    auto agent = std::make_shared<TestPrinterAgent>("integration-agent");
+    NetworkAgent network(nullptr, agent);
+    DeviceManager manager(&network, false, &app_config.config);
+    MachineObject object(&manager, &network, "Test printer", "integration-device", "192.0.2.10");
+    object.dev_connection_type = GENERATE("lan", "cloud");
+    const std::vector<std::string> colors{"FF000080"};
+
+    REQUIRE(object.command_ams_filament_settings(1, 2, "filament-id", "setting-id", colors.front(), "PLA", 190, 220,
+                                                 colors) == 0);
+
+    const json& payload = agent->published_message.at("print");
+    CHECK(payload.at("cols").get<std::vector<std::string>>() == colors);
+    CHECK(payload.at("ctype") == 2);
+}
Author	SHA1	Message	Date
Noisyfox	d4fabbf7c8	Fix AMS gradient rendering, color presets and printer writeback (#16252 ) * Fix external spool gradient and multicolor rendering * Display AMS gradients and multicolors in color popup * Preserve AMS gradient selection through color popup * Match popup selections by full filament color data * Align AMS Lite gradient geometry with BambuStudio * Align AMS color palette with BambuStudio presets * Match Bambu circular color rendering without background masks * Preserve AMS gradient colors when applying filament settings * Match AMS preview gradient swatches to the solid color shape	2026-10-15 19:43:07 +08:00
SoftFever	51efb24752	Complete traditional Chinese translations (#16513 )	2026-10-15 19:32:54 +08:00
SoftFever	cf9ec18df5	Complete the Simplified Chinese translations (#16512 )	2026-10-15 19:32:30 +08:00
Tobias Glothandyw4z	258f927a0f	Fix: Crash by null mainframe in BackgroundSlicingProcess for CLI (#15367 ) * add nullptr check * use plater from app instead mainframe --------- Co-authored-by: yw4z <ywsyildiz@gmail.com>	2026-10-15 14:14:26 +03:00
Arthur Porto	6aa613ccf0	Fix Z contouring failing on objects with several instances (#16461 ) * Let Z contouring slice objects that have several instances The contouring step refused any object with more than one instance. The instances of a PrintObject differ only by their XY shift, so the mesh is now placed with the first instance of the PrintObject being contoured. * Say in the Z contouring comment how instances map to print objects * Check that Z contouring follows each instance as it is turned	2026-10-15 07:30:57 -03:00
SoftFever	7599868797	Update locale	2026-10-15 17:41:23 +08:00
Lam Wei Lun	81ec931990	Keep global shortcuts out of in-canvas ImGui text fields Space opened the Speed Dial and Ctrl+P the Preferences while the text tool's box or a sketch value field was being typed into. Those fields are ImGui drawn on the GL canvas, so the canvas is the focused wx window and focus_keeps_space() cannot see them; the CHAR_HOOK handler took the chord first and the field never saw the key. Skip the global shortcut dispatch while ImGui reports that one of its items owns the keyboard and the focused window is not a wxControl.	2026-10-15 17:20:56 +08:00
Volodimer BabchynskyyandSoftFever	8fd97b5120	Pass EXTRUDER_OTHER_LAYER_TEMP in RatRig single-toolhead start G-code (#16444 ) RatOS 2.1 START_PRINT aborts when the parameter is missing. The IDEX profiles already pass it. Co-authored-by: SoftFever <103989404+SoftFever@users.noreply.github.com>	2026-10-15 16:57:47 +08:00
Paul	aacc36b9d2	Add official School House Spools PLA and PETG filament profiles (#15429 ) # Description Adds School House Spools PLA and PETG to the global Orca Filament Library. Both are standard PLA and PETG, so Bambu PLA Basic / PETG Basic served as the baseline for tuning values. The one intentional difference is PETG nozzle temperature (252°C vs Bambu's inherited 255°C default), based on our own testing. # Screenshots/Recordings/Graphs N/A ## Tests Ran scripts/assign_vendor_setting_ids.py to generate setting_id values, and scripts/orca_extra_profile_check.py --vendor="OrcaFilamentLibrary" --check-filaments --check-materials to validate. No new errors or warnings introduced (pre-existing unrelated errors in other vendors' profiles were not touched). [How to Download Pull Requests Artifacts for Testing](https://www.orcaslicer.com/wiki/how_to_download_pr_artifacts)	2026-10-15 16:36:21 +08:00