Jelajahi Sumber

Queue: choose the order "Any model" jobs pick printers in (#2915) (#3547)

Keybored 1 Minggu lalu
induk
melakukan
1147d6a993

+ 1 - 0
CHANGELOG.md

@@ -27,6 +27,7 @@ All notable changes to Bambuddy will be documented in this file.
 - **Profile defaults is compact and has Apply all** — Settings → Filament → Profile defaults showed every default as a large box with all its presets and K profiles, so a few products already filled the page. Each default is now one line (product, colour, slicer preset, and how many printer presets and K profiles it has), sorted by product, with a search box; click a line to see its presets and K profiles. The list scrolls on its own. **Apply all** applies every default to the spools in stock in one go, and like Apply to existing spools it only fills in what a spool doesn't have yet. Wiki updated.
 - **Slicer sidecars on Bambu Studio 02.09.01.70 and OrcaSlicer 2.5.0 (#3442)** — The Bambu Studio sidecar now ships the H3C printer presets (0.2, 0.4, 0.6 and 0.8 mm nozzle). OrcaSlicer has no H3C presets yet. OrcaSlicer 2.5.0 ships its bundled presets in a new packed format, so the sidecar image now fetches the same release's presets as JSON for its preset handling. Slicing with a printer preset saved under a name of its own keeps working on 2.5.0; the sliced file then names the Bambu preset it was saved from as its printer preset. Sidecar images built for older slicer versions work as before.
 - **"Any model" jobs go to the printer with the fewest print hours (#3480, sponsor vote Q4 2026)** — When several printers of a model can take a job, the queue used to pick the first one in its list, so on a farm the same printer got most of the work. It now picks the one with the fewest print hours (the Maintenance counter, including baseline hours entered there), so jobs and wear spread across the farm. Preferred colours still come first, and the queue powers on the least used printer too when it has to switch one on with an Auto Power On plug.
+- **Choose which printer an "Any model" job takes (#2915, requested by @bryanmahin, contributed by @Keybored02 in #3547)** — Several printers of a model can take an "Any model" job, and the one with the fewest print hours always got it. **Settings > Workflow > Printer Order for Any-Model Jobs** now chooses: the fewest print hours (the default, as before), the most (use up the machines near replacement first), the printer idle the longest (by its last finished print; one that never printed goes first), or the printers' own priority, a number in **Edit Printer** (lowest first, none last). The order only ranks printers that can take the job: a busy, offline or filament-short printer is still passed over, and preferred colours still come first. Powering a printer on with an Auto Power On plug follows the same order.
 
 ### Fixed
 - **Long uploads to an A1 no longer end in a failed or unreadable print (#3538, reported by @SaadShaya7)** — Two problems at the handoff from a slow upload to the print command, seen with a 19 MB file that took three minutes. When the printer didn't confirm the upload, Bambuddy read the file size back, logged that the file was incomplete, and sent the print command anyway: the printer was still writing the file and either stayed idle or reported that it could not parse it. Bambuddy now keeps reading the size for up to two minutes, sends the print command once the file is complete, and otherwise retries the upload. And because the A1 sends no status while it receives a file, Bambuddy took the silence for a dead connection and reconnected just before the print command, which then failed the job. Silence during an upload, and in the minute after it, no longer counts as a dead connection; this also applies to firmware uploads.

+ 4 - 0
backend/app/core/database.py

@@ -6006,6 +6006,10 @@ async def _run_migrations(conn):
     await _safe_execute(conn, f"ALTER TABLE print_log_entries ADD COLUMN wear_cost {float_type}")
     await _safe_execute(conn, f"ALTER TABLE print_archives ADD COLUMN wear_cost {float_type}")
 
+    # Migration: a printer's place in the pick order of "Any model" jobs (#2915).
+    # Nullable: no printer has one until the order setting is "priority" and one is set.
+    await _safe_execute(conn, "ALTER TABLE printers ADD COLUMN dispatch_priority INTEGER")
+
     # Migration: when each spool was last dried, at what temperature and for
     # how long (#2863). Nullable: no spool has a drying record until one ends.
     datetime_type = "DATETIME" if is_sqlite() else "TIMESTAMP"

+ 4 - 1
backend/app/models/printer.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 
-from sqlalchemy import JSON, Boolean, DateTime, Float, String, false, func
+from sqlalchemy import JSON, Boolean, DateTime, Float, Integer, String, false, func
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from backend.app.core.database import Base
@@ -25,6 +25,9 @@ class Printer(Base):
     # What an hour of printing costs in wear on this machine (#694). Empty or 0
     # leaves wear cost off for the printer.
     wear_cost_per_hour: Mapped[float | None] = mapped_column(Float, nullable=True)
+    # Place in the order "Any model" jobs pick printers when Settings > Queue >
+    # printer order is "priority" (#2915): lowest first, empty last, ties by id.
+    dispatch_priority: Mapped[int | None] = mapped_column(Integer, nullable=True)
     runtime_seconds: Mapped[int] = mapped_column(
         default=0
     )  # Accumulated active runtime (RUNNING state only — see #1521)

+ 4 - 0
backend/app/schemas/printer.py

@@ -181,6 +181,9 @@ class PrinterUpdate(IgnoresNullForRequiredColumns):
     print_hours_offset: float | None = None
     # Wear cost per printing hour (#694); null or 0 turns it off.
     wear_cost_per_hour: float | None = Field(default=None, ge=0, le=100000)
+    # Place in the pick order of "Any model" jobs when the order setting is "priority"
+    # (#2915); lowest first, null last.
+    dispatch_priority: int | None = Field(default=None, ge=0, le=100000)
     external_camera_url: str | None = None
     external_camera_type: str | None = None
     external_camera_enabled: bool | None = None
@@ -204,6 +207,7 @@ class PrinterResponse(PrinterBase):
     supports_nozzle_flow_type: bool = True
     print_hours_offset: float = 0.0
     wear_cost_per_hour: float | None = None  # #694
+    dispatch_priority: int | None = None  # #2915
     external_camera_url: str | None = None
     external_camera_type: str | None = None
     external_camera_enabled: bool = False

+ 8 - 0
backend/app/schemas/settings.py

@@ -491,6 +491,13 @@ class AppSettings(BaseModel):
         default=False,
         description="Shortest Job First — scheduler prioritizes shorter print jobs over longer ones",
     )
+    model_dispatch_order: Literal["fewest_hours", "most_hours", "least_recently_used", "priority"] = Field(
+        default="fewest_hours",
+        description=(
+            "Which printer an 'Any model' job takes when several can run it (#2915): the one with the fewest "
+            "print hours, the most, the one idle the longest, or the first by the printers' own priority."
+        ),
+    )
     queue_max_concurrent_uploads: int = Field(
         default=4,
         ge=1,
@@ -825,6 +832,7 @@ class AppSettingsUpdate(BaseModel):
     # Capped by camera_light.MAX_DELAY_SECONDS: the finish photo's budget
     # has no more to spare.
     camera_light_delay: float | None = Field(default=None, ge=0, le=5)
+    model_dispatch_order: Literal["fewest_hours", "most_hours", "least_recently_used", "priority"] | None = None
     preferred_slicer: str | None = None
     open_in_slicer: str | None = None
     slice_engine: str | None = None

+ 68 - 2
backend/app/services/print_scheduler.py

@@ -1265,6 +1265,44 @@ def _wear_order(printer: Printer) -> tuple[float, int]:
     return hours, printer.id
 
 
+def _hours_of(printer: Printer) -> float:
+    return (printer.runtime_seconds or 0) / 3600.0 + (printer.print_hours_offset or 0.0)
+
+
+def _order_printers(
+    printers: list[Printer], order: str, last_finished: dict[int, datetime] | None = None
+) -> list[Printer]:
+    """Sort the printers an "Any model" job could take into the order they are picked (#2915).
+
+    Whatever the strategy, ties fall back to the printer id, so the outcome is
+    reproducible.
+
+    * ``fewest_hours`` (the default, #3480): the least worn machine first.
+    * ``most_hours``: the most worn first, to use up the machines already near
+      replacement.
+    * ``least_recently_used``: the printer that finished a print longest ago;
+      one that never has goes first.
+    * ``priority``: the printers' own ``dispatch_priority``, lowest first; one
+      without goes last.
+    """
+    if order == "most_hours":
+        return sorted(printers, key=lambda p: (-_hours_of(p), p.id))
+    if order == "least_recently_used":
+        finished = last_finished or {}
+        never = datetime.min
+        return sorted(printers, key=lambda p: (finished.get(p.id, never), p.id))
+    if order == "priority":
+        return sorted(
+            printers,
+            key=lambda p: (
+                p.dispatch_priority is None,
+                p.dispatch_priority if p.dispatch_priority is not None else 0,
+                p.id,
+            ),
+        )
+    return sorted(printers, key=_wear_order)
+
+
 class PrintScheduler:
     """Background scheduler that processes the print queue."""
 
@@ -3284,7 +3322,8 @@ class PrintScheduler:
         only be woken onto a printer the matcher would also have considered.
         ``printer_scope`` is the job creator's (#1727).
 
-        Fewest print hours first (#3480): both take the first printer that
+        In the order of Settings > Queue > printer order (#2915), fewest print
+        hours first by default (#3480): both take the first printer that
         fits, so an "Any" job goes to the least worn machine and a farm's jobs
         spread by wear instead of all landing on the lowest id. The hours are
         the maintenance counter's (runtime plus the baseline offset), which
@@ -3302,7 +3341,34 @@ class PrintScheduler:
         if (clause := printer_scope.where_strict(Printer.id)) is not None:
             query = query.where(clause)
         result = await db.execute(query)
-        return sorted(result.scalars().all(), key=_wear_order)
+        printers = list(result.scalars().all())
+        order = await self._get_model_dispatch_order(db)
+        last_finished: dict[int, datetime] | None = None
+        if order == "least_recently_used" and printers:
+            last_finished = await self._last_finished_by_printer(db, [p.id for p in printers])
+        return _order_printers(printers, order, last_finished)
+
+    async def _get_model_dispatch_order(self, db: AsyncSession) -> str:
+        """The order setting (#2915); anything unknown reads as the default."""
+        result = await db.execute(select(Settings).where(Settings.key == "model_dispatch_order"))
+        setting = result.scalar_one_or_none()
+        value = (setting.value if setting else "") or ""
+        return value if value in ("most_hours", "least_recently_used", "priority") else "fewest_hours"
+
+    async def _last_finished_by_printer(self, db: AsyncSession, printer_ids: list[int]) -> dict[int, datetime]:
+        """When each printer last finished a print, from the Print Log; none for one that never has."""
+        from backend.app.models.print_log import PrintLogEntry
+
+        result = await db.execute(
+            select(PrintLogEntry.printer_id, func.max(PrintLogEntry.completed_at))
+            .where(PrintLogEntry.printer_id.in_(printer_ids), PrintLogEntry.completed_at.is_not(None))
+            .group_by(PrintLogEntry.printer_id)
+        )
+        return {
+            printer_id: finished
+            for printer_id, finished in result.all()
+            if printer_id is not None and finished is not None
+        }
 
     async def _wakeable_printer_ids(self, db: AsyncSession) -> set[int]:
         """Printer IDs that at least one enabled ``auto_on`` plug can power on.

+ 59 - 0
backend/tests/unit/test_dispatch_priority_migration_2915.py

@@ -0,0 +1,59 @@
+"""The startup migration gives a database from before #2915 the printers.dispatch_priority column."""
+
+from __future__ import annotations
+
+import pytest
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import create_async_engine
+
+from backend.app.core.database import run_migrations
+
+
+@pytest.fixture(autouse=True)
+def force_sqlite_dialect(monkeypatch):
+    from backend.app.core import database as database_module, db_dialect
+
+    monkeypatch.setattr(db_dialect, "is_sqlite", lambda: True)
+    monkeypatch.setattr(db_dialect, "is_postgres", lambda: False)
+    monkeypatch.setattr(database_module, "is_sqlite", lambda: True)
+
+
+async def _columns(engine) -> list[str]:
+    async with engine.connect() as conn:
+        return [row[1] for row in (await conn.execute(text("PRAGMA table_info(printers)"))).all()]
+
+
+@pytest.mark.asyncio
+async def test_the_column_is_added_once_and_existing_printers_keep_no_priority():
+    import importlib
+    import pkgutil
+
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+    import backend.app.models as models_pkg
+    from backend.app.core.database import Base
+
+    # Every table the migrations touch, not just those the package imports.
+    for module in pkgutil.iter_modules(models_pkg.__path__):
+        importlib.import_module(f"backend.app.models.{module.name}")
+    from backend.app.models.printer import Printer
+
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:", echo=False)
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    async with AsyncSession(engine) as db:
+        db.add(Printer(name="P", serial_number="S", ip_address="1.2.3.4", access_code="x"))
+        await db.commit()
+    async with engine.begin() as conn:
+        await conn.execute(text("ALTER TABLE printers DROP COLUMN dispatch_priority"))
+    assert "dispatch_priority" not in await _columns(engine)
+
+    for _ in range(2):  # idempotent
+        async with engine.begin() as conn:
+            await run_migrations(conn)
+
+    assert "dispatch_priority" in await _columns(engine)
+    async with engine.connect() as conn:
+        value = (await conn.execute(text("SELECT dispatch_priority FROM printers"))).scalar_one()
+    await engine.dispose()
+    assert value is None

+ 225 - 0
backend/tests/unit/test_scheduler_dispatch_order_2915.py

@@ -0,0 +1,225 @@
+"""The order an "Any model" job picks its printer in is a setting (#2915).
+
+Fewest print hours stays the default (#3480). The setting adds the most hours
+(use up the machines near replacement), the printer idle the longest, and the
+printers' own priority.
+"""
+
+from datetime import datetime
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+import pytest
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+
+import backend.app.models  # noqa: F401 - populate Base.metadata
+from backend.app.core.database import Base
+from backend.app.models.print_log import PrintLogEntry
+from backend.app.models.printer import Printer
+from backend.app.models.settings import Settings
+from backend.app.services.print_scheduler import PrintScheduler, _order_printers
+
+HOUR = 3600
+
+
+def _p(pid, hours=0.0, priority=None):
+    return SimpleNamespace(
+        id=pid, runtime_seconds=int(hours * HOUR), print_hours_offset=0.0, dispatch_priority=priority
+    )
+
+
+def _ids(printers):
+    return [p.id for p in printers]
+
+
+class TestOrdering:
+    def test_fewest_hours_is_the_default_and_an_unknown_value(self):
+        printers = [_p(1, 900), _p(2, 100), _p(3, 20)]
+
+        assert _ids(_order_printers(printers, "fewest_hours")) == [3, 2, 1]
+        assert _ids(_order_printers(printers, "nonsense")) == [3, 2, 1]
+
+    def test_most_hours_puts_the_most_worn_first_and_ties_go_by_id(self):
+        printers = [_p(1, 20), _p(2, 900), _p(3, 20), _p(4, 100)]
+
+        assert _ids(_order_printers(printers, "most_hours")) == [2, 4, 1, 3]
+
+    def test_the_baseline_offset_counts_as_hours(self):
+        old = SimpleNamespace(id=1, runtime_seconds=0, print_hours_offset=500.0, dispatch_priority=None)
+
+        assert _ids(_order_printers([_p(2, 10), old], "most_hours")) == [1, 2]
+
+    def test_least_recently_used_takes_the_longest_idle_and_never_used_first(self):
+        printers = [_p(1), _p(2), _p(3), _p(4)]
+        finished = {1: datetime(2026, 5, 3), 2: datetime(2026, 5, 1), 4: datetime(2026, 5, 2)}
+
+        # 3 never printed; then 2 (May 1), 4 (May 2), 1 (May 3).
+        assert _ids(_order_printers(printers, "least_recently_used", finished)) == [3, 2, 4, 1]
+
+    def test_least_recently_used_without_any_history_goes_by_id(self):
+        assert _ids(_order_printers([_p(3), _p(1), _p(2)], "least_recently_used", {})) == [1, 2, 3]
+
+    def test_priority_is_lowest_first_empty_last_and_ties_by_id(self):
+        printers = [_p(1, priority=None), _p(2, priority=5), _p(3, priority=1), _p(4, priority=5), _p(5, priority=0)]
+
+        # 0 is a real priority (first), not "none".
+        assert _ids(_order_printers(printers, "priority")) == [5, 3, 2, 4, 1]
+
+
+async def _farm(setting: str | None, **printers):
+    """X1Cs by id with (runtime hours, priority); the setting row is written when given."""
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:", echo=False)
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    session_maker = async_sessionmaker(engine, expire_on_commit=False)
+    async with session_maker() as db:
+        for key, (hours, priority) in printers.items():
+            pid = int(key.removeprefix("p"))
+            db.add(
+                Printer(
+                    id=pid,
+                    name=f"X1C-{pid}",
+                    serial_number=f"X1C000{pid}",
+                    ip_address=f"192.0.2.{pid}",
+                    access_code="x",
+                    model="X1C",
+                    is_active=True,
+                    runtime_seconds=int(hours * HOUR),
+                    dispatch_priority=priority,
+                )
+            )
+        if setting is not None:
+            db.add(Settings(key="model_dispatch_order", value=setting))
+        await db.commit()
+    return engine, SimpleNamespace(session_maker=session_maker)
+
+
+async def _find(ctx, exclude=frozenset()):
+    scheduler = PrintScheduler()
+    with (
+        patch("backend.app.services.print_scheduler.printer_manager.is_connected", MagicMock(return_value=True)),
+        patch.object(scheduler, "_is_printer_idle", MagicMock(return_value=True)),
+    ):
+        async with ctx.session_maker() as db:
+            return await scheduler._find_idle_printer_for_model(db, "X1C", set(exclude))
+
+
+# Printer 1 is the most worn, 3 the least; priority puts 2 first, then 1, and 3 has none.
+PRINTERS = {"p1": (900, 2), "p2": (100, 1), "p3": (20, None)}
+
+
+class TestTheSettingDecidesWhoGetsTheJob:
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        ("setting", "expected"),
+        [
+            (None, 3),  # not set: fewest hours, as before
+            ("fewest_hours", 3),
+            ("most_hours", 1),
+            ("priority", 2),
+            ("garbage", 3),  # a bad row never stops the queue
+        ],
+    )
+    async def test_first_pick(self, setting, expected):
+        engine, ctx = await _farm(setting, **PRINTERS)
+        try:
+            assert await _find(ctx) == (expected, None)
+        finally:
+            await engine.dispose()
+
+    @pytest.mark.asyncio
+    async def test_a_busy_first_choice_passes_the_job_down_the_order(self):
+        engine, ctx = await _farm("priority", **PRINTERS)
+        try:
+            assert await _find(ctx, exclude={2}) == (1, None)
+            assert await _find(ctx, exclude={2, 1}) == (3, None)
+        finally:
+            await engine.dispose()
+
+    @pytest.mark.asyncio
+    async def test_least_recently_used_follows_the_print_log(self):
+        engine, ctx = await _farm("least_recently_used", **PRINTERS)
+        try:
+            async with ctx.session_maker() as db:
+                db.add_all(
+                    [
+                        PrintLogEntry(printer_id=3, status="completed", completed_at=datetime(2026, 5, 3)),
+                        PrintLogEntry(printer_id=3, status="completed", completed_at=datetime(2026, 4, 1)),
+                        PrintLogEntry(printer_id=1, status="completed", completed_at=datetime(2026, 5, 1)),
+                        PrintLogEntry(printer_id=2, status="completed", completed_at=datetime(2026, 5, 2)),
+                    ]
+                )
+                await db.commit()
+
+            # Each printer counts by its latest finish: 1 (May 1) is idle longest.
+            assert await _find(ctx) == (1, None)
+        finally:
+            await engine.dispose()
+
+    @pytest.mark.asyncio
+    async def test_a_printer_that_never_printed_is_the_least_recently_used(self):
+        engine, ctx = await _farm("least_recently_used", **PRINTERS)
+        try:
+            async with ctx.session_maker() as db:
+                db.add_all(
+                    [
+                        PrintLogEntry(printer_id=1, status="completed", completed_at=datetime(2026, 5, 1)),
+                        PrintLogEntry(printer_id=2, status="completed", completed_at=datetime(2026, 5, 2)),
+                    ]
+                )
+                await db.commit()
+
+            assert await _find(ctx) == (3, None)
+        finally:
+            await engine.dispose()
+
+    @pytest.mark.asyncio
+    async def test_the_wake_step_and_the_matcher_share_the_order(self):
+        """Both read _printers_for_model, so a printer is woken in the order it would be picked."""
+        engine, ctx = await _farm("most_hours", **PRINTERS)
+        try:
+            async with ctx.session_maker() as db:
+                printers = await PrintScheduler()._printers_for_model(db, "X1C")
+            assert [p.id for p in printers] == [1, 2, 3]
+        finally:
+            await engine.dispose()
+
+
+class TestApi:
+    @pytest.mark.asyncio
+    @pytest.mark.integration
+    async def test_the_order_setting_defaults_saves_and_rejects_others(self, async_client):
+        default = await async_client.get("/api/v1/settings/")
+        assert default.json()["model_dispatch_order"] == "fewest_hours"
+
+        saved = await async_client.put("/api/v1/settings/", json={"model_dispatch_order": "priority"})
+        assert saved.status_code == 200, saved.text
+        assert (await async_client.get("/api/v1/settings/")).json()["model_dispatch_order"] == "priority"
+
+        refused = await async_client.put("/api/v1/settings/", json={"model_dispatch_order": "alphabetical"})
+        assert refused.status_code == 422
+
+    @pytest.mark.asyncio
+    @pytest.mark.integration
+    async def test_a_printer_priority_round_trips_and_clears(self, async_client, printer_factory):
+        printer = await printer_factory()
+
+        set_ = await async_client.patch(f"/api/v1/printers/{printer.id}", json={"dispatch_priority": 3})
+        assert set_.status_code == 200, set_.text
+        assert set_.json()["dispatch_priority"] == 3
+
+        cleared = await async_client.patch(f"/api/v1/printers/{printer.id}", json={"dispatch_priority": None})
+        assert cleared.json()["dispatch_priority"] is None
+
+        negative = await async_client.patch(f"/api/v1/printers/{printer.id}", json={"dispatch_priority": -1})
+        assert negative.status_code == 422
+
+    @pytest.mark.asyncio
+    @pytest.mark.integration
+    async def test_a_patch_without_it_leaves_the_priority_alone(self, async_client, printer_factory):
+        printer = await printer_factory()
+        await async_client.patch(f"/api/v1/printers/{printer.id}", json={"dispatch_priority": 2})
+
+        resp = await async_client.patch(f"/api/v1/printers/{printer.id}", json={"name": "Renamed"})
+
+        assert resp.json()["dispatch_priority"] == 2

+ 123 - 0
frontend/src/__tests__/components/EditPrinterDispatchPriority.test.tsx

@@ -0,0 +1,123 @@
+/**
+ * A printer's place in the pick order of any-model jobs (#2915), in the Edit
+ * Printer dialog: a number saves, empty clears it, and 0 is a place, not "none".
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { render } from '../utils';
+import { PrintersPage } from '../../pages/PrintersPage';
+import { http, HttpResponse } from 'msw';
+import { server } from '../mocks/server';
+
+const basePrinter = {
+  id: 1,
+  name: 'X1 Carbon',
+  ip_address: '192.168.1.100',
+  serial_number: '00M09A350100001',
+  access_code: '12345678',
+  model: 'X1C',
+  enabled: true,
+  nozzle_diameter: 0.4,
+  nozzle_type: 'hardened_steel',
+  location: null,
+  auto_archive: true,
+  is_active: true,
+  wear_cost_per_hour: null,
+  dispatch_priority: null as number | null,
+  created_at: '2024-01-01T00:00:00Z',
+  updated_at: '2024-01-01T00:00:00Z',
+};
+
+const mockStatus = {
+  connected: true,
+  state: 'IDLE',
+  progress: 0,
+  layer_num: 0,
+  total_layers: 0,
+  temperatures: { nozzle: 25, bed: 25, chamber: 25 },
+  remaining_time: 0,
+  filename: null,
+  wifi_signal: -50,
+  vt_tray: [],
+};
+
+let saved: Record<string, unknown> | null = null;
+
+function mockPrinter(printer: typeof basePrinter) {
+  server.use(
+    http.get('/api/v1/printers/', () => HttpResponse.json([printer])),
+    http.get('/api/v1/printers/:id/status', () => HttpResponse.json(mockStatus)),
+    http.get('/api/v1/queue/', () => HttpResponse.json([])),
+    http.post('/api/v1/printers/diagnostic', () =>
+      HttpResponse.json({ printer_id: null, ip_address: printer.ip_address, overall: 'ok', checks: [] }),
+    ),
+    http.patch('/api/v1/printers/:id', async ({ request }) => {
+      saved = (await request.json()) as Record<string, unknown>;
+      return HttpResponse.json({ ...printer, ...saved });
+    }),
+  );
+}
+
+async function openEditModal() {
+  render(<PrintersPage />);
+  await waitFor(() => expect(screen.getByText('X1 Carbon')).toBeInTheDocument());
+  const menuBtn = [...document.querySelectorAll('button')].find((b) =>
+    b.querySelector('.lucide-ellipsis-vertical'),
+  )!;
+  await userEvent.click(menuBtn);
+  await userEvent.click(await screen.findByRole('button', { name: /^edit$/i }));
+  await screen.findByText('Edit Printer');
+}
+
+describe('EditPrinterModal priority for any-model jobs', () => {
+  beforeEach(() => {
+    saved = null;
+  });
+
+  it('saves a priority the user enters', async () => {
+    mockPrinter(basePrinter);
+    await openEditModal();
+
+    await userEvent.type(screen.getByLabelText(/Priority for any-model jobs/i), '3');
+    await userEvent.click(screen.getByRole('button', { name: /save changes/i }));
+
+    await waitFor(() => expect(saved).not.toBeNull());
+    expect(saved!.dispatch_priority).toBe(3);
+  });
+
+  it('sends null when it was never set', async () => {
+    mockPrinter(basePrinter);
+    await openEditModal();
+
+    await userEvent.click(screen.getByRole('button', { name: /save changes/i }));
+
+    await waitFor(() => expect(saved).not.toBeNull());
+    expect(saved!.dispatch_priority).toBeNull();
+  });
+
+  it('clears it when the field is emptied', async () => {
+    mockPrinter({ ...basePrinter, dispatch_priority: 2 });
+    await openEditModal();
+
+    const field = screen.getByLabelText(/Priority for any-model jobs/i);
+    expect(field).toHaveValue(2);
+    await userEvent.clear(field);
+    await userEvent.click(screen.getByRole('button', { name: /save changes/i }));
+
+    await waitFor(() => expect(saved).not.toBeNull());
+    expect(saved!.dispatch_priority).toBeNull();
+  });
+
+  it('keeps 0 as a place, not as none', async () => {
+    mockPrinter({ ...basePrinter, dispatch_priority: 0 });
+    await openEditModal();
+
+    expect(screen.getByLabelText(/Priority for any-model jobs/i)).toHaveValue(0);
+    await userEvent.click(screen.getByRole('button', { name: /save changes/i }));
+
+    await waitFor(() => expect(saved).not.toBeNull());
+    expect(saved!.dispatch_priority).toBe(0);
+  });
+});

+ 87 - 0
frontend/src/__tests__/pages/SettingsPageDispatchOrder.test.tsx

@@ -0,0 +1,87 @@
+/**
+ * Printer order for any-model jobs (#2915): a select in the Workflow tab, saved
+ * like the other settings, defaulting to fewest print hours.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { fireEvent, screen, waitFor } from '@testing-library/react';
+import { render } from '../utils';
+import { SettingsPage } from '../../pages/SettingsPage';
+import { http, HttpResponse } from 'msw';
+import { server } from '../mocks/server';
+import { setAuthToken } from '../../api/client';
+
+const settings: Record<string, unknown> = {
+  auto_archive: true,
+  currency: 'USD',
+  time_format: 'system',
+  date_format: 'system',
+  check_updates: false,
+  check_printer_firmware: false,
+  external_url: window.location.origin,
+};
+
+let saved: Array<Record<string, unknown>>;
+
+function serve(current: Record<string, unknown>) {
+  server.use(
+    http.get('/api/v1/settings/', () => HttpResponse.json(current)),
+    http.put('/api/v1/settings/', async ({ request }) => {
+      const body = (await request.json()) as Record<string, unknown>;
+      saved.push(body);
+      return HttpResponse.json({ ...current, ...body });
+    }),
+    http.get('/api/v1/printers/', () => HttpResponse.json([])),
+    http.get('/api/v1/notifications/', () => HttpResponse.json([])),
+    http.get('/api/v1/auth/status', () => HttpResponse.json({ auth_enabled: false, requires_setup: false })),
+  );
+}
+
+beforeEach(() => {
+  window.history.replaceState({}, '', '/?tab=queue');
+  vi.mocked(localStorage.getItem).mockReset();
+  setAuthToken(null);
+  saved = [];
+});
+
+async function select() {
+  const el = (await screen.findByLabelText('Pick the printer')) as HTMLSelectElement;
+  // Let the loaded settings land first; a change before that is overwritten.
+  await new Promise((resolve) => setTimeout(resolve, 200));
+  return el;
+}
+
+describe('SettingsPage - printer order for any-model jobs (#2915)', () => {
+  it('shows fewest print hours when nothing is set, and saves nothing', async () => {
+    serve(settings);
+    render(<SettingsPage />);
+
+    expect((await select()).value).toBe('fewest_hours');
+    await new Promise((resolve) => setTimeout(resolve, 800));
+    expect(saved).toEqual([]);
+  });
+
+  it('offers the four strategies', async () => {
+    serve(settings);
+    render(<SettingsPage />);
+
+    const options = Array.from((await select()).options).map((o) => o.value);
+    expect(options).toEqual(['fewest_hours', 'most_hours', 'least_recently_used', 'priority']);
+  });
+
+  it('shows the saved choice', async () => {
+    serve({ ...settings, model_dispatch_order: 'least_recently_used' });
+    render(<SettingsPage />);
+
+    expect((await select()).value).toBe('least_recently_used');
+  });
+
+  it('saves a changed choice', async () => {
+    serve(settings);
+    render(<SettingsPage />);
+
+    fireEvent.change(await select(), { target: { value: 'priority' } });
+
+    await waitFor(() => expect(saved.at(-1)?.model_dispatch_order).toBe('priority'), { timeout: 3000 });
+  });
+});

+ 6 - 0
frontend/src/api/client.ts

@@ -490,6 +490,7 @@ export interface Printer {
   plate_detection_enabled: boolean;  // Check plate before print
   plate_detection_roi?: PlateDetectionROI;  // ROI for plate detection
   wear_cost_per_hour: number | null;  // Wear cost per printing hour (#694)
+  dispatch_priority: number | null;  // Place in the pick order of any-model jobs, lowest first (#2915)
   wled_config: WLEDConfig | null;
   created_at: string;
   updated_at: string;
@@ -823,6 +824,7 @@ export interface PrinterCreate {
   plate_detection_enabled?: boolean;
   plate_detection_roi?: PlateDetectionROI;
   wear_cost_per_hour?: number | null;
+  dispatch_priority?: number | null;
   wled_config?: WLEDConfig | null;
 }
 
@@ -1477,6 +1479,8 @@ export interface APIKeyCreateResponse extends APIKey {
 export type CalibrationMode = 'off' | 'on' | 'auto';
 
 // Settings types
+export type ModelDispatchOrder = 'fewest_hours' | 'most_hours' | 'least_recently_used' | 'priority';
+
 export interface AppSettings {
   auto_archive: boolean;
   save_thumbnails: boolean;
@@ -1635,6 +1639,8 @@ export interface AppSettings {
   require_plate_clear: boolean;
   // Shortest job first scheduling
   queue_shortest_first: boolean;
+  // Which printer an any-model job takes when several can run it (#2915).
+  model_dispatch_order: ModelDispatchOrder;
   // How many printers the queue may upload to at once (#2555). 1 restores the
   // old strictly-serial behaviour, where every printer waited out every other
   // printer's transfer.

+ 10 - 0
frontend/src/i18n/locales/de.ts

@@ -650,6 +650,8 @@ export default {
       autoArchiveLabel: 'Abgeschlossene Drucke automatisch archivieren',
       wearCostLabel: 'Verschleißkosten pro Druckstunde ({{currency}})',
       wearCostHelp: 'Was eine Druckstunde diesen Drucker an Verschleiß und Ersatzteilen kostet. Wird ab jetzt zu den Kosten jedes Drucks addiert; frühere Drucke bleiben unverändert. Leer lassen zum Abschalten.',
+      dispatchPriorityLabel: 'Priorität für Aufträge an ein beliebiges Modell',
+      dispatchPriorityHelp: 'Gilt, wenn die Druckerreihenfolge für Aufträge an ein beliebiges Modell auf die Priorität der Drucker steht. Die niedrigste Zahl wird zuerst gewählt, leer kommt zuletzt.',
       fromPrinterSettings: 'Aus Druckereinstellungen',
       modelOptional: 'Modell (optional)',
       saveChanges: 'Änderungen speichern',
@@ -2548,6 +2550,14 @@ export default {
     concurrentUploadsDescription: 'Wie viele Drucker die Warteschlange gleichzeitig mit Dateien versorgen darf. Drucker nehmen Dateien nur langsam entgegen (ein großer Druck kann mehrere Minuten dauern), und jeder wartet, bis er an der Reihe ist — bei größeren Farmen verhindert ein höherer Wert also, dass der letzte Drucker eines Stapels erst alle anderen Übertragungen abwarten muss. Verringern Sie ihn, wenn Ihr Netzwerk oder der Bambuddy-Host mit parallelen Übertragungen Probleme hat.',
     concurrentUploadsLabel: 'Gleichzeitig belieferte Drucker',
     concurrentUploadsHelp: '1 beliefert immer nur einen Drucker (das bisherige Verhalten). Standard ist 4.',
+    dispatchOrderTitle: 'Druckerreihenfolge für Aufträge an ein beliebiges Modell',
+    dispatchOrderDescription: 'Wird ein Auftrag für irgendeinen Drucker eines Modells eingereiht, entscheidet dies, welcher der möglichen Drucker ihn bekommt. Ein Drucker, der beschäftigt, offline oder knapp an Filament ist, wird übergangen, egal wie die Reihenfolge ist.',
+    dispatchOrderLabel: 'Drucker wählen',
+    dispatchOrderFewestHours: 'mit den wenigsten Betriebsstunden (Standard)',
+    dispatchOrderMostHours: 'mit den meisten Betriebsstunden',
+    dispatchOrderLeastRecentlyUsed: 'der am längsten unbenutzt ist',
+    dispatchOrderPriority: 'nach der Priorität jedes Druckers',
+    dispatchOrderHelp: 'Wenigste Stunden verteilt den Verschleiß auf alle Drucker. Meiste Stunden nutzt zuerst die Geräte, die bald ersetzt werden. Am längsten unbenutzt richtet sich nach dem zuletzt beendeten Druck jedes Druckers; einer, der noch nie gedruckt hat, kommt zuerst. Nach Priorität folgt dem Feld Priorität in den Druckereinstellungen: die niedrigste Zahl zuerst, Drucker ohne Wert zuletzt.',
     staggeredStart: 'Versetzter Start',
     staggeredStartDescription: 'Standard-Gruppengröße und -Intervall beim Staffeln von Mehrdrucker-Batchstarts. Pro Batch im Druck-Dialog überschreibbar.',
     preheatTitle: 'Vorheizen & Heat Soak',

+ 10 - 0
frontend/src/i18n/locales/en.ts

@@ -655,6 +655,8 @@ export default {
       autoArchiveLabel: 'Auto-archive completed prints',
       wearCostLabel: 'Wear cost per printing hour ({{currency}})',
       wearCostHelp: 'What an hour of printing costs this printer in wear and parts. It is added to the cost of every print from now on; earlier prints are not changed. Leave empty to turn it off.',
+      dispatchPriorityLabel: 'Priority for any-model jobs',
+      dispatchPriorityHelp: "Used when the printer order for any-model jobs is set to the printers' priority. The lowest number is picked first; empty goes last.",
       fromPrinterSettings: 'From printer settings',
       modelOptional: 'Model (optional)',
       saveChanges: 'Save Changes',
@@ -2570,6 +2572,14 @@ export default {
     concurrentUploadsDescription: 'How many printers the queue may send files to at the same time. Printers receive files slowly (a large print can take several minutes), and each one waits its turn — so on a bigger fleet, raising this is what stops the last printer in a batch from waiting out every transfer before it. Lower it if your network or Bambuddy host struggles with parallel transfers.',
     concurrentUploadsLabel: 'Printers uploaded to at once',
     concurrentUploadsHelp: '1 sends to one printer at a time (the old behaviour). Default is 4.',
+    dispatchOrderTitle: 'Printer Order for Any-Model Jobs',
+    dispatchOrderDescription: 'When a job is queued for any printer of a model, this decides which of the printers that can take it gets it. A printer that is busy, offline or short of filament is passed over, whatever the order.',
+    dispatchOrderLabel: 'Pick the printer',
+    dispatchOrderFewestHours: 'With the fewest print hours (default)',
+    dispatchOrderMostHours: 'With the most print hours',
+    dispatchOrderLeastRecentlyUsed: 'Idle the longest',
+    dispatchOrderPriority: 'By the priority set on each printer',
+    dispatchOrderHelp: "Fewest hours spreads the wear over the farm. Most hours uses up the machines near replacement first. Idle the longest goes by each printer's last finished print, and one that never printed goes first. By priority follows the Priority field in each printer's settings: the lowest number first, printers without one last.",
     staggeredStart: 'Staggered Start',
     staggeredStartDescription: 'Default group size and interval when staggering multi-printer batch starts. Can be overridden per batch in the print modal.',
     preheatTitle: 'Preheat & Heat Soak',

+ 10 - 0
frontend/src/i18n/locales/es.ts

@@ -650,6 +650,8 @@ export default {
       autoArchiveLabel: 'Archivar automáticamente las impresiones completadas',
       wearCostLabel: 'Coste de desgaste por hora de impresión ({{currency}})',
       wearCostHelp: 'Lo que una hora de impresión le cuesta a esta impresora en desgaste y piezas. Se suma al coste de cada impresión a partir de ahora; las impresiones anteriores no cambian. Déjalo vacío para desactivarlo.',
+      dispatchPriorityLabel: 'Prioridad para trabajos de cualquier modelo',
+      dispatchPriorityHelp: 'Se usa cuando el orden de impresoras para trabajos de cualquier modelo está en la prioridad de las impresoras. Se elige primero el número más bajo; vacío va al final.',
       fromPrinterSettings: 'Desde los ajustes de la impresora',
       modelOptional: 'Modelo (opcional)',
       saveChanges: 'Guardar cambios',
@@ -2551,6 +2553,14 @@ export default {
     concurrentUploadsDescription: 'Cuántas impresoras pueden recibir archivos de la cola al mismo tiempo. Las impresoras reciben los archivos lentamente (una impresión grande puede tardar varios minutos) y cada una espera su turno, así que en una granja grande subir este valor evita que la última impresora de un lote tenga que esperar a que terminen todas las transferencias anteriores. Bájalo si tu red o el host de Bambuddy tienen problemas con transferencias en paralelo.',
     concurrentUploadsLabel: 'Impresoras atendidas a la vez',
     concurrentUploadsHelp: '1 envía a una impresora cada vez (el comportamiento anterior). El valor predeterminado es 4.',
+    dispatchOrderTitle: 'Orden de impresoras para trabajos de cualquier modelo',
+    dispatchOrderDescription: 'Cuando un trabajo se pone en cola para cualquier impresora de un modelo, esto decide cuál de las que pueden aceptarlo lo recibe. Una impresora ocupada, sin conexión o con poco filamento se salta, sea cual sea el orden.',
+    dispatchOrderLabel: 'Elegir la impresora',
+    dispatchOrderFewestHours: 'Con menos horas de impresión (predeterminado)',
+    dispatchOrderMostHours: 'Con más horas de impresión',
+    dispatchOrderLeastRecentlyUsed: 'Inactiva desde hace más tiempo',
+    dispatchOrderPriority: 'Por la prioridad de cada impresora',
+    dispatchOrderHelp: 'Menos horas reparte el desgaste por toda la granja. Más horas gasta primero las máquinas cerca de su reemplazo. Inactiva desde hace más tiempo va por la última impresión terminada de cada impresora, y la que nunca imprimió va primero. Por prioridad sigue el campo Prioridad de cada impresora: el número más bajo primero, las que no lo tienen al final.',
     staggeredStart: 'Inicio escalonado',
     staggeredStartDescription: 'Tamaño de grupo e intervalo predeterminados al escalonar los inicios de lotes en varias impresoras. Se pueden anular por lote en la ventana de impresión.',
     preheatTitle: 'Precalentamiento y Heat Soak',

+ 10 - 0
frontend/src/i18n/locales/fr.ts

@@ -650,6 +650,8 @@ export default {
       autoArchiveLabel: 'Auto-archiver les impressions terminées',
       wearCostLabel: 'Coût d\'usure par heure d\'impression ({{currency}})',
       wearCostHelp: 'Ce qu\'une heure d\'impression coûte à cette imprimante en usure et en pièces. Il s\'ajoute au coût de chaque impression à partir de maintenant ; les impressions précédentes ne changent pas. Laissez vide pour le désactiver.',
+      dispatchPriorityLabel: 'Priorité pour les travaux de modèle quelconque',
+      dispatchPriorityHelp: "Utilisée quand l'ordre des imprimantes pour les travaux de modèle quelconque est sur la priorité des imprimantes. Le plus petit nombre est choisi en premier ; vide passe en dernier.",
       fromPrinterSettings: 'Depuis les paramètres imprimante',
       modelOptional: 'Modèle (optionnel)',
       saveChanges: 'Enregistrer les modifications',
@@ -2503,6 +2505,14 @@ export default {
     concurrentUploadsDescription: "Nombre d'imprimantes auxquelles la file d'attente peut envoyer des fichiers en même temps. Les imprimantes reçoivent les fichiers lentement (une grosse impression peut prendre plusieurs minutes) et chacune attend son tour : sur un parc important, augmenter cette valeur évite que la dernière imprimante d'un lot doive attendre la fin de tous les transferts précédents. Réduisez-la si votre réseau ou votre hôte Bambuddy supporte mal les transferts parallèles.",
     concurrentUploadsLabel: 'Imprimantes servies simultanément',
     concurrentUploadsHelp: "1 n'envoie qu'à une imprimante à la fois (l'ancien comportement). Valeur par défaut : 4.",
+    dispatchOrderTitle: 'Ordre des imprimantes pour les travaux de modèle quelconque',
+    dispatchOrderDescription: "Quand un travail est mis en file pour n'importe quelle imprimante d'un modèle, ce réglage décide laquelle de celles qui peuvent le prendre le reçoit. Une imprimante occupée, hors ligne ou à court de filament est passée, quel que soit l'ordre.",
+    dispatchOrderLabel: "Choisir l'imprimante",
+    dispatchOrderFewestHours: "Avec le moins d'heures d'impression (par défaut)",
+    dispatchOrderMostHours: "Avec le plus d'heures d'impression",
+    dispatchOrderLeastRecentlyUsed: 'Inactive depuis le plus longtemps',
+    dispatchOrderPriority: 'Selon la priorité de chaque imprimante',
+    dispatchOrderHelp: "Le moins d'heures répartit l'usure sur le parc. Le plus d'heures use d'abord les machines proches du remplacement. Inactive depuis le plus longtemps suit la dernière impression terminée de chaque imprimante, et celle qui n'a jamais imprimé passe en premier. Selon la priorité suit le champ Priorité des réglages de chaque imprimante : le plus petit nombre d'abord, celles sans valeur en dernier.",
     staggeredStart: 'Démarrage échelonné',
     staggeredStartDescription: 'Taille de groupe et intervalle par défaut lors de l\'échelonnement des démarrages de lots multi-imprimantes. Modifiable par lot dans la fenêtre d\'impression.',
     preheatTitle: 'Préchauffage & Heat Soak',

+ 10 - 0
frontend/src/i18n/locales/it.ts

@@ -650,6 +650,8 @@ export default {
       autoArchiveLabel: 'Archivia automaticamente stampe completate',
       wearCostLabel: 'Costo di usura per ora di stampa ({{currency}})',
       wearCostHelp: 'Quanto costa un\'ora di stampa a questa stampante in usura e ricambi. Viene aggiunto al costo di ogni stampa da ora in poi; le stampe precedenti non cambiano. Lascia vuoto per disattivarlo.',
+      dispatchPriorityLabel: 'Priorità per i lavori di qualsiasi modello',
+      dispatchPriorityHelp: "Usata quando l'ordine delle stampanti per i lavori di qualsiasi modello è sulla priorità delle stampanti. Si sceglie prima il numero più basso; vuoto va per ultimo.",
       fromPrinterSettings: 'Dalle impostazioni della stampante',
       modelOptional: 'Modello (opzionale)',
       saveChanges: 'Salva modifiche',
@@ -2503,6 +2505,14 @@ export default {
     concurrentUploadsDescription: "Quante stampanti possono ricevere file dalla coda contemporaneamente. Le stampanti ricevono i file lentamente (una stampa grande può richiedere diversi minuti) e ognuna aspetta il proprio turno: su un parco macchine ampio, aumentare questo valore evita che l'ultima stampante di un lotto debba attendere la fine di tutti i trasferimenti precedenti. Riducilo se la rete o l'host Bambuddy fatica con i trasferimenti paralleli.",
     concurrentUploadsLabel: 'Stampanti servite contemporaneamente',
     concurrentUploadsHelp: '1 invia a una stampante alla volta (il comportamento precedente). Il valore predefinito è 4.',
+    dispatchOrderTitle: 'Ordine delle stampanti per i lavori di qualsiasi modello',
+    dispatchOrderDescription: "Quando un lavoro è in coda per una qualsiasi stampante di un modello, questa impostazione decide quale tra quelle che possono prenderlo lo riceve. Una stampante occupata, offline o a corto di filamento viene saltata, qualunque sia l'ordine.",
+    dispatchOrderLabel: 'Scegli la stampante',
+    dispatchOrderFewestHours: 'Con meno ore di stampa (predefinito)',
+    dispatchOrderMostHours: 'Con più ore di stampa',
+    dispatchOrderLeastRecentlyUsed: 'Inattiva da più tempo',
+    dispatchOrderPriority: 'Per la priorità di ogni stampante',
+    dispatchOrderHelp: "Meno ore distribuisce l'usura su tutta la flotta. Più ore consuma prima le macchine vicine alla sostituzione. Inattiva da più tempo segue l'ultima stampa terminata di ogni stampante, e quella che non ha mai stampato va per prima. Per priorità segue il campo Priorità nelle impostazioni di ogni stampante: il numero più basso per primo, quelle senza valore per ultime.",
     staggeredStart: 'Avvio scaglionato',
     staggeredStartDescription: 'Dimensione gruppo e intervallo predefiniti per scaglionare avvii di batch multi-stampante. Sovrascrivibili per batch nella finestra di stampa.',
     preheatTitle: 'Preriscaldo & Heat Soak',

+ 10 - 0
frontend/src/i18n/locales/ja.ts

@@ -649,6 +649,8 @@ export default {
       autoArchiveLabel: '完了した印刷を自動アーカイブ',
       wearCostLabel: '印刷1時間あたりの摩耗コスト({{currency}})',
       wearCostHelp: 'このプリンターで1時間印刷したときの摩耗と部品のコストです。今後のすべての印刷のコストに加算されます。過去の印刷は変更されません。空欄にすると無効になります。',
+      dispatchPriorityLabel: '機種指定ジョブの優先度',
+      dispatchPriorityHelp: '機種指定ジョブのプリンター順序が「各プリンターの優先度順」のときに使われます。小さい数字が先に選ばれ、空欄は最後です。',
       fromPrinterSettings: 'プリンターの設定から取得',
       modelOptional: 'モデル(任意)',
       saveChanges: '変更を保存',
@@ -2547,6 +2549,14 @@ export default {
     concurrentUploadsDescription: 'キューが同時にファイルを送信できるプリンター数です。プリンターのファイル受信は遅く(大きな造形では数分かかることもあります)、各プリンターは順番を待ちます。台数の多い環境では、この値を上げることで、バッチ内の最後のプリンターが先行するすべての転送を待たずに済みます。ネットワークや Bambuddy ホストが並列転送に耐えられない場合は下げてください。',
     concurrentUploadsLabel: '同時に送信するプリンター数',
     concurrentUploadsHelp: '1 にすると 1 台ずつ送信します(従来の動作)。既定値は 4 です。',
+    dispatchOrderTitle: '機種指定ジョブのプリンター順序',
+    dispatchOrderDescription: '機種内のどのプリンターでもよいジョブをキューに入れたとき、受け取れるプリンターのうちどれが取るかをこの設定で決めます。使用中、オフライン、フィラメント不足のプリンターは、順序にかかわらず飛ばされます。',
+    dispatchOrderLabel: 'プリンターの選び方',
+    dispatchOrderFewestHours: '印刷時間が最も短い(デフォルト)',
+    dispatchOrderMostHours: '印刷時間が最も長い',
+    dispatchOrderLeastRecentlyUsed: '最も長く使われていない',
+    dispatchOrderPriority: '各プリンターの優先度順',
+    dispatchOrderHelp: '「最も短い」は摩耗をプリンター全体に分散します。「最も長い」は交換が近い機械から使い切ります。「最も長く使われていない」は各プリンターの最後に完了した印刷で決め、一度も印刷していないものが先になります。「優先度順」は各プリンターの設定にある優先度の値が小さい順で、値のないプリンターは最後です。',
     staggeredStart: '段階的開始',
     staggeredStartDescription: '複数プリンターのバッチ開始を段階的に行う際のデフォルトのグループサイズと間隔。プリントモーダルでバッチごとに上書き可能。',
     preheatTitle: 'プレヒート & ヒートソーク',

+ 10 - 0
frontend/src/i18n/locales/ko.ts

@@ -617,6 +617,8 @@ export default {
       autoArchiveLabel: '완료된 인쇄 자동 아카이브',
       wearCostLabel: '출력 시간당 마모 비용 ({{currency}})',
       wearCostHelp: '이 프린터로 한 시간 출력할 때 드는 마모 및 부품 비용입니다. 지금부터 모든 출력의 비용에 더해지며, 이전 출력은 바뀌지 않습니다. 비워 두면 꺼집니다.',
+      dispatchPriorityLabel: '모델 지정 작업 우선순위',
+      dispatchPriorityHelp: '모델 지정 작업의 프린터 순서가 프린터별 우선순위일 때 사용합니다. 작은 숫자가 먼저 선택되고, 비어 있으면 마지막입니다.',
       fromPrinterSettings: '프린터 설정에서',
       modelOptional: '모델 (선택사항)',
       saveChanges: '변경사항 저장'
@@ -2425,6 +2427,14 @@ export default {
     concurrentUploadsDescription: '대기열이 동시에 파일을 보낼 수 있는 프린터 수입니다. 프린터는 파일을 느리게 받으며(큰 출력물은 몇 분이 걸릴 수 있습니다) 각 프린터는 자기 차례를 기다립니다. 따라서 프린터가 많은 환경에서는 이 값을 높이면 배치의 마지막 프린터가 앞선 모든 전송이 끝나기를 기다리지 않아도 됩니다. 네트워크나 Bambuddy 호스트가 병렬 전송을 버거워하면 값을 낮추세요.',
     concurrentUploadsLabel: '동시에 전송할 프린터 수',
     concurrentUploadsHelp: '1이면 한 번에 한 대씩 전송합니다(기존 동작). 기본값은 4입니다.',
+    dispatchOrderTitle: '모델 지정 작업의 프린터 순서',
+    dispatchOrderDescription: '어느 프린터든 상관없는 모델 지정 작업이 대기열에 들어갈 때, 받을 수 있는 프린터 중 어느 것이 맡을지 이 설정이 정합니다. 사용 중이거나 오프라인이거나 필라멘트가 부족한 프린터는 순서와 관계없이 건너뜁니다.',
+    dispatchOrderLabel: '프린터 선택 기준',
+    dispatchOrderFewestHours: '인쇄 시간이 가장 적은 것 (기본값)',
+    dispatchOrderMostHours: '인쇄 시간이 가장 많은 것',
+    dispatchOrderLeastRecentlyUsed: '가장 오래 쉰 것',
+    dispatchOrderPriority: '프린터별 우선순위',
+    dispatchOrderHelp: '가장 적은 시간은 마모를 전체에 고르게 나눕니다. 가장 많은 시간은 교체가 가까운 장비를 먼저 씁니다. 가장 오래 쉰 것은 각 프린터의 마지막으로 끝난 인쇄를 기준으로 하며, 한 번도 인쇄하지 않은 것이 먼저입니다. 우선순위는 각 프린터 설정의 우선순위 값이 작은 순이며, 값이 없는 프린터는 마지막입니다.',
     staggeredStart: '엇갈린 시작',
     staggeredStartDescription: '다중 프린터 일괄 시작 시 기본 그룹 크기 및 간격. 인쇄 모달에서 배치별로 재정의할 수 있습니다.',
     preheatTitle: '예열 & 히트 소크',

+ 10 - 0
frontend/src/i18n/locales/nl.ts

@@ -653,6 +653,8 @@ export default {
       autoArchiveLabel: 'Voltooide afdrukken automatisch archiveren',
       wearCostLabel: 'Slijtagekosten per printuur ({{currency}})',
       wearCostHelp: 'Wat een uur printen deze printer kost aan slijtage en onderdelen. Wordt vanaf nu bij de kosten van elke print opgeteld; eerdere prints veranderen niet. Laat leeg om het uit te zetten.',
+      dispatchPriorityLabel: 'Prioriteit voor opdrachten voor een willekeurig model',
+      dispatchPriorityHelp: 'Gebruikt wanneer de printervolgorde voor opdrachten voor een willekeurig model op de prioriteit van de printers staat. Het laagste getal wordt eerst gekozen; leeg komt laatst.',
       fromPrinterSettings: 'Uit printerinstellingen',
       modelOptional: 'Model (optioneel)',
       saveChanges: 'Wijzigingen opslaan',
@@ -2568,6 +2570,14 @@ export default {
     concurrentUploadsDescription: 'Hoeveel printers de wachtrij tegelijk bestanden mag sturen. Printers ontvangen bestanden langzaam (een grote afdruk kan enkele minuten duren) en elke printer wacht op zijn beurt — bij een groter printerpark voorkomt een hogere waarde dat de laatste printer in een batch op alle eerdere overdrachten moet wachten. Verlaag dit als je netwerk of Bambuddy-host moeite heeft met parallelle overdrachten.',
     concurrentUploadsLabel: 'Printers tegelijk uploaden',
     concurrentUploadsHelp: '1 verstuurt naar één printer tegelijk (het oude gedrag). Standaard is 4.',
+    dispatchOrderTitle: 'Printervolgorde voor opdrachten voor een willekeurig model',
+    dispatchOrderDescription: 'Wanneer een opdracht voor een willekeurige printer van een model in de wachtrij komt, bepaalt dit welke van de printers die hem kunnen nemen hem krijgt. Een printer die bezig of offline is of weinig filament heeft, wordt overgeslagen, welke volgorde ook.',
+    dispatchOrderLabel: 'Kies de printer',
+    dispatchOrderFewestHours: 'Met de minste printuren (standaard)',
+    dispatchOrderMostHours: 'Met de meeste printuren',
+    dispatchOrderLeastRecentlyUsed: 'Die het langst stilstaat',
+    dispatchOrderPriority: 'Op de prioriteit van elke printer',
+    dispatchOrderHelp: 'Minste uren spreidt de slijtage over de hele farm. Meeste uren gebruikt eerst de machines die bijna vervangen moeten worden. Langst stilstaand gaat op de laatst afgeronde print van elke printer, en een printer die nog nooit geprint heeft gaat eerst. Op prioriteit volgt het veld Prioriteit in de instellingen van elke printer: het laagste getal eerst, printers zonder waarde laatst.',
     staggeredStart: 'Gespreide start',
     staggeredStartDescription: 'Standaard groepsgrootte en interval bij gespreid starten van batches over meerdere printers. Kan per batch in het afdrukvenster worden overschreven.',
     preheatTitle: 'Voorverwarmen en warmtestabilisatie',

+ 10 - 0
frontend/src/i18n/locales/pl.ts

@@ -655,6 +655,8 @@ export default {
       autoArchiveLabel: 'Automatycznie archiwizuj ukończone wydruki',
       wearCostLabel: 'Koszt zużycia na godzinę druku ({{currency}})',
       wearCostHelp: 'Ile godzina drukowania kosztuje tę drukarkę w zużyciu i częściach. Od teraz jest doliczany do kosztu każdego wydruku; wcześniejsze wydruki nie są zmieniane. Pozostaw puste, aby wyłączyć.',
+      dispatchPriorityLabel: 'Priorytet dla zadań na dowolny model',
+      dispatchPriorityHelp: 'Używany, gdy kolejność drukarek dla zadań na dowolny model ustawiono na priorytet drukarek. Najniższy numer jest wybierany pierwszy; puste idzie na koniec.',
       fromPrinterSettings: 'Z ustawień drukarki',
       modelOptional: 'Model (opcjonalnie)',
       saveChanges: 'Zapisz zmiany',
@@ -2570,6 +2572,14 @@ export default {
     concurrentUploadsDescription: 'Do ilu drukarek kolejka może jednocześnie wysyłać pliki. Drukarki odbierają pliki powoli (duży wydruk może trwać kilka minut), a każda czeka na swoją kolej — dlatego przy większej flocie zwiększenie tej wartości sprawia, że ostatnia drukarka w partii nie czeka na zakończenie wszystkich wcześniejszych transferów. Zmniejsz ją, jeśli sieć lub host Bambuddy nie radzi sobie z równoległymi transferami.',
     concurrentUploadsLabel: 'Liczba drukarek jednocześnie',
     concurrentUploadsHelp: '1 wysyła do jednej drukarki naraz (dawne zachowanie). Domyślnie 4.',
+    dispatchOrderTitle: 'Kolejność drukarek dla zadań na dowolny model',
+    dispatchOrderDescription: 'Gdy zadanie trafia do kolejki dla dowolnej drukarki danego modelu, to ustawienie decyduje, która z drukarek mogących je przyjąć je dostanie. Drukarka zajęta, offline lub z małą ilością filamentu jest pomijana, niezależnie od kolejności.',
+    dispatchOrderLabel: 'Wybierz drukarkę',
+    dispatchOrderFewestHours: 'Z najmniejszą liczbą godzin druku (domyślnie)',
+    dispatchOrderMostHours: 'Z największą liczbą godzin druku',
+    dispatchOrderLeastRecentlyUsed: 'Nieużywaną najdłużej',
+    dispatchOrderPriority: 'Według priorytetu ustawionego w każdej drukarce',
+    dispatchOrderHelp: 'Najmniej godzin rozkłada zużycie na całą flotę. Najwięcej godzin najpierw zużywa maszyny bliskie wymiany. Nieużywana najdłużej kieruje się ostatnim zakończonym wydrukiem każdej drukarki, a ta, która jeszcze nie drukowała, idzie pierwsza. Według priorytetu kieruje się polem Priorytet w ustawieniach każdej drukarki: najniższy numer pierwszy, drukarki bez wartości na końcu.',
     staggeredStart: 'Start rozłożony w czasie',
     staggeredStartDescription: 'Domyślna wielkość grupy i odstęp przy rozkładaniu w czasie startu partii na wielu drukarkach. Można je zmienić dla każdej partii w oknie druku.',
     preheatTitle: 'Podgrzewanie i wygrzewanie',

+ 10 - 0
frontend/src/i18n/locales/pt-BR.ts

@@ -650,6 +650,8 @@ export default {
       autoArchiveLabel: 'Arquivar automaticamente impressões concluídas',
       wearCostLabel: 'Custo de desgaste por hora de impressão ({{currency}})',
       wearCostHelp: 'Quanto uma hora de impressão custa a esta impressora em desgaste e peças. É somado ao custo de cada impressão a partir de agora; impressões anteriores não mudam. Deixe vazio para desativar.',
+      dispatchPriorityLabel: 'Prioridade para trabalhos de qualquer modelo',
+      dispatchPriorityHelp: 'Usada quando a ordem das impressoras para trabalhos de qualquer modelo está na prioridade das impressoras. O menor número é escolhido primeiro; vazio vai por último.',
       fromPrinterSettings: 'A partir das configurações da impressora',
       modelOptional: 'Modelo (opcional)',
       saveChanges: 'Salvar alterações',
@@ -2503,6 +2505,14 @@ export default {
     concurrentUploadsDescription: 'Quantas impressoras a fila pode abastecer com arquivos ao mesmo tempo. As impressoras recebem os arquivos lentamente (uma impressão grande pode levar vários minutos) e cada uma espera sua vez — portanto, em um parque maior, aumentar este valor evita que a última impressora de um lote tenha de esperar todas as transferências anteriores. Reduza-o se a sua rede ou o host do Bambuddy tiver dificuldade com transferências paralelas.',
     concurrentUploadsLabel: 'Impressoras abastecidas de uma vez',
     concurrentUploadsHelp: '1 envia para uma impressora por vez (o comportamento anterior). O padrão é 4.',
+    dispatchOrderTitle: 'Ordem das impressoras para trabalhos de qualquer modelo',
+    dispatchOrderDescription: 'Quando um trabalho entra na fila para qualquer impressora de um modelo, isto decide qual das impressoras que podem recebê-lo fica com ele. Uma impressora ocupada, offline ou com pouco filamento é pulada, seja qual for a ordem.',
+    dispatchOrderLabel: 'Escolher a impressora',
+    dispatchOrderFewestHours: 'Com menos horas de impressão (padrão)',
+    dispatchOrderMostHours: 'Com mais horas de impressão',
+    dispatchOrderLeastRecentlyUsed: 'Parada há mais tempo',
+    dispatchOrderPriority: 'Pela prioridade de cada impressora',
+    dispatchOrderHelp: 'Menos horas distribui o desgaste por toda a frota. Mais horas gasta primeiro as máquinas perto da troca. Parada há mais tempo vai pela última impressão concluída de cada impressora, e a que nunca imprimiu vai primeiro. Pela prioridade segue o campo Prioridade nos ajustes de cada impressora: o menor número primeiro, as sem valor por último.',
     staggeredStart: 'Início escalonado',
     staggeredStartDescription: 'Tamanho de grupo e intervalo padrão ao escalonar inícios de lotes multi-impressora. Pode ser sobrescrito por lote no modal de impressão.',
     preheatTitle: 'Pré-aquecimento & Heat Soak',

+ 10 - 0
frontend/src/i18n/locales/ru.ts

@@ -622,6 +622,8 @@ export default {
       autoArchiveLabel: "Автоматически архивировать завершённые печати",
       wearCostLabel: 'Стоимость износа за час печати ({{currency}})',
       wearCostHelp: 'Во что обходится этому принтеру час печати с учётом износа и запчастей. С этого момента добавляется к стоимости каждой печати; прежние печати не меняются. Оставьте пустым, чтобы отключить.',
+      dispatchPriorityLabel: 'Приоритет для заданий на любую модель',
+      dispatchPriorityHelp: 'Используется, когда порядок принтеров для заданий на любую модель выбран по приоритету принтеров. Первым выбирается наименьшее число; пустое идёт последним.',
       fromPrinterSettings: "Из настроек принтера",
       modelOptional: "Модель (необязательно)",
       saveChanges: "Сохранить изменения",
@@ -2428,6 +2430,14 @@ export default {
     concurrentUploadsDescription: "Количество принтеров, на которые очередь может одновременно отправлять файлы. Передача файлов на принтеры выполняется медленно: крупная модель может загружаться несколько минут, а каждый принтер ждёт своей очереди. В большом парке увеличение этого значения сокращает ожидание последних принтеров в группе. Уменьшите его, если сеть или сервер Bambuddy плохо справляются с параллельной передачей.",
     concurrentUploadsLabel: "Одновременно загружать на принтеры",
     concurrentUploadsHelp: "Значение 1 отправляет файл только на один принтер за раз, как в прежнем режиме. По умолчанию: 4.",
+    dispatchOrderTitle: 'Порядок принтеров для заданий на любую модель',
+    dispatchOrderDescription: 'Когда задание ставится в очередь на любой принтер модели, эта настройка решает, какой из подходящих принтеров его получит. Занятый, отключённый или с нехваткой филамента принтер пропускается при любом порядке.',
+    dispatchOrderLabel: 'Выбирать принтер',
+    dispatchOrderFewestHours: 'с наименьшей наработкой (по умолчанию)',
+    dispatchOrderMostHours: 'с наибольшей наработкой',
+    dispatchOrderLeastRecentlyUsed: 'простаивающий дольше всех',
+    dispatchOrderPriority: 'по приоритету, заданному у каждого принтера',
+    dispatchOrderHelp: 'Наименьшая наработка распределяет износ по всему парку. Наибольшая сначала вырабатывает машины, близкие к замене. Простаивающий дольше всех определяется по последней завершённой печати каждого принтера, а тот, что ещё не печатал, идёт первым. По приоритету следует полю «Приоритет» в настройках каждого принтера: сначала наименьшее число, принтеры без значения последними.',
     staggeredStart: "Поэтапный запуск",
     staggeredStartDescription: "Размер группы и интервал по умолчанию при поэтапном запуске партии на нескольких принтерах. Для каждой партии значения можно изменить в окне запуска печати.",
     preheatTitle: "Преднагрев и выдержка",

+ 10 - 0
frontend/src/i18n/locales/sv.ts

@@ -653,6 +653,8 @@ export default {
       autoArchiveLabel: 'Auto-arkivera färdiga utskrifter',
       wearCostLabel: 'Slitagekostnad per utskriftstimme ({{currency}})',
       wearCostHelp: 'Vad en timmes utskrift kostar den här skrivaren i slitage och delar. Läggs från och med nu till kostnaden för varje utskrift; tidigare utskrifter ändras inte. Lämna tomt för att stänga av.',
+      dispatchPriorityLabel: 'Prioritet för jobb till valfri modell',
+      dispatchPriorityHelp: 'Används när skrivarordningen för jobb till valfri modell är satt till skrivarnas prioritet. Lägsta talet väljs först; tomt kommer sist.',
       fromPrinterSettings: 'Från skrivarens inställningar',
       modelOptional: 'Modell (valfritt)',
       saveChanges: 'Spara ändringar',
@@ -2600,6 +2602,14 @@ export default {
     concurrentUploadsDescription: 'Hur många skrivare kön kan skicka filer till samtidigt. Skrivare tar emot filer långsamt (en stor utskrift kan ta flera minuter), och varje skrivare väntar på sin tur — så med en större flotta är det detta som förhindrar att den sista skrivaren i en batch väntar på alla överföringar före den. Sänk detta om ditt nätverk eller din Bambuddy-värd har svårt med parallella överföringar.',
     concurrentUploadsLabel: 'Skrivare som laddas upp till samtidigt',
     concurrentUploadsHelp: '1 skickar till en skrivare i taget (gammalt beteende). Standard är 4.',
+    dispatchOrderTitle: 'Skrivarordning för jobb till valfri modell',
+    dispatchOrderDescription: 'När ett jobb köas för vilken skrivare som helst av en modell avgör detta vilken av de skrivare som kan ta det som får det. En skrivare som är upptagen, offline eller har för lite filament hoppas över, oavsett ordning.',
+    dispatchOrderLabel: 'Välj skrivaren',
+    dispatchOrderFewestHours: 'Med färst utskriftstimmar (standard)',
+    dispatchOrderMostHours: 'Med flest utskriftstimmar',
+    dispatchOrderLeastRecentlyUsed: 'Som stått stilla längst',
+    dispatchOrderPriority: 'Efter prioriteten på varje skrivare',
+    dispatchOrderHelp: 'Färst timmar sprider slitaget över hela parken. Flest timmar använder först maskinerna nära utbyte. Stått stilla längst går efter varje skrivares senast avslutade utskrift, och en som aldrig skrivit ut kommer först. Efter prioritet följer fältet Prioritet i varje skrivares inställningar: lägsta talet först, skrivare utan värde sist.',
     staggeredStart: 'Förskjuten start',
     staggeredStartDescription: 'Standardgruppstorlek och intervall vid förskjuten start av batchutskrifter på flera skrivare. Kan åsidosättas per batch i utskriftsdialogrutan.',
     preheatTitle: 'Förvärme',

+ 10 - 0
frontend/src/i18n/locales/tr.ts

@@ -650,6 +650,8 @@ export default {
       autoArchiveLabel: 'Tamamlanan baskıları otomatik arşivle',
       wearCostLabel: 'Baskı saati başına aşınma maliyeti ({{currency}})',
       wearCostHelp: 'Bir saatlik baskının bu yazıcıya aşınma ve parça olarak maliyeti. Bundan sonra her baskının maliyetine eklenir; önceki baskılar değişmez. Kapatmak için boş bırakın.',
+      dispatchPriorityLabel: 'Herhangi model işleri için öncelik',
+      dispatchPriorityHelp: 'Herhangi model işleri için yazıcı sırası yazıcıların önceliğine ayarlıyken kullanılır. En küçük sayı önce seçilir; boş olan en sona gider.',
       fromPrinterSettings: 'Yazıcı ayarlarından',
       modelOptional: 'Model (isteğe bağlı)',
       saveChanges: 'Değişiklikleri Kaydet',
@@ -2552,6 +2554,14 @@ export default {
     concurrentUploadsDescription: 'Kuyruğun aynı anda kaç yazıcıya dosya gönderebileceği. Yazıcılar dosyaları yavaş alır (büyük bir baskı birkaç dakika sürebilir) ve her biri sırasını bekler; bu nedenle büyük bir filoda bu değeri artırmak, bir gruptaki son yazıcının kendisinden önceki tüm aktarımları beklemesini önler. Ağınız veya Bambuddy sunucunuz paralel aktarımlarda zorlanıyorsa değeri düşürün.',
     concurrentUploadsLabel: 'Aynı anda dosya gönderilen yazıcı sayısı',
     concurrentUploadsHelp: "1, aynı anda tek yazıcıya gönderir (eski davranış). Varsayılan 4'tür.",
+    dispatchOrderTitle: 'Herhangi Model İşleri için Yazıcı Sırası',
+    dispatchOrderDescription: 'Bir iş, bir modelin herhangi bir yazıcısı için kuyruğa alındığında, onu alabilecek yazıcılardan hangisinin alacağını bu ayar belirler. Meşgul, çevrimdışı veya filamenti az olan yazıcı, sıra ne olursa olsun atlanır.',
+    dispatchOrderLabel: 'Yazıcıyı seç',
+    dispatchOrderFewestHours: 'En az baskı saatine sahip (varsayılan)',
+    dispatchOrderMostHours: 'En çok baskı saatine sahip',
+    dispatchOrderLeastRecentlyUsed: 'En uzun süredir boşta olan',
+    dispatchOrderPriority: 'Her yazıcıda ayarlanan önceliğe göre',
+    dispatchOrderHelp: 'En az saat, aşınmayı tüm filoya yayar. En çok saat, değişime yakın makineleri önce kullanır. En uzun süredir boşta olan, her yazıcının son biten baskısına göre belirlenir; hiç baskı yapmamış olan önce gelir. Önceliğe göre, her yazıcının ayarlarındaki Öncelik alanını izler: en küçük sayı önce, değeri olmayanlar en sonda.',
     staggeredStart: 'Kademeli Başlatma',
     staggeredStartDescription: 'Çoklu yazıcı toplu başlatmaları kademelendirilirken varsayılan grup boyutu ve aralığı. Baskı modalinde yığın başına geçersiz kılınabilir.',
     preheatTitle: 'Ön Isıtma & Heat Soak',

+ 10 - 0
frontend/src/i18n/locales/uk.ts

@@ -653,6 +653,8 @@ export default {
       autoArchiveLabel: "Автоматичне архівування завершених роздруківок",
       wearCostLabel: 'Вартість зносу за годину друку ({{currency}})',
       wearCostHelp: 'Скільки цьому принтеру коштує година друку в зносі та запчастинах. Відтепер додається до вартості кожного друку; попередні друки не змінюються. Залиште порожнім, щоб вимкнути.',
+      dispatchPriorityLabel: 'Пріоритет для завдань на будь-яку модель',
+      dispatchPriorityHelp: 'Використовується, коли порядок принтерів для завдань на будь-яку модель вибрано за пріоритетом принтерів. Першим обирається найменше число; порожнє йде останнім.',
       fromPrinterSettings: "З налаштувань принтера",
       modelOptional: "Модель (необов’язково)",
       saveChanges: "Зберегти зміни",
@@ -2566,6 +2568,14 @@ export default {
     concurrentUploadsDescription: "Кількість принтерів, на які черга може одночасно надсилати файли. Передавання на принтери відбувається повільно — великий файл може передаватися кілька хвилин — і кожен принтер чекає своєї черги. Для великого парку збільшення цього значення скорочує очікування останнього принтера в партії. Зменште його, якщо мережа або сервер Bambuddy не справляється з паралельними передаваннями.",
     concurrentUploadsLabel: "Кількість принтерів для одночасного передавання",
     concurrentUploadsHelp: "1 надсилає на один принтер за раз (стара поведінка). За замовчуванням 4.",
+    dispatchOrderTitle: 'Порядок принтерів для завдань на будь-яку модель',
+    dispatchOrderDescription: 'Коли завдання ставиться в чергу на будь-який принтер моделі, це налаштування вирішує, який із принтерів, що можуть його взяти, його отримає. Зайнятий, офлайн або з нестачею філаменту принтер пропускається за будь-якого порядку.',
+    dispatchOrderLabel: 'Обирати принтер',
+    dispatchOrderFewestHours: 'з найменшим напрацюванням (за замовчуванням)',
+    dispatchOrderMostHours: 'з найбільшим напрацюванням',
+    dispatchOrderLeastRecentlyUsed: 'що простоює найдовше',
+    dispatchOrderPriority: 'за пріоритетом, заданим у кожного принтера',
+    dispatchOrderHelp: 'Найменше напрацювання розподіляє знос по всьому парку. Найбільше спершу вичерпує машини, близькі до заміни. Той, що простоює найдовше, визначається за останнім завершеним друком кожного принтера, а той, що ще не друкував, іде першим. За пріоритетом слідує полю «Пріоритет» у налаштуваннях кожного принтера: спершу найменше число, принтери без значення останніми.',
     staggeredStart: "Поетапний запуск",
     staggeredStartDescription: "Типовий розмір групи та інтервал для поетапного запуску партії на кількох принтерах. Значення можна змінити для кожної партії у вікні друку.",
     preheatTitle: "Попереднє нагрівання й термовитримка",

+ 10 - 0
frontend/src/i18n/locales/zh-CN.ts

@@ -650,6 +650,8 @@ export default {
       autoArchiveLabel: '自动归档已完成的打印',
       wearCostLabel: '每打印小时磨损成本({{currency}})',
       wearCostHelp: '这台打印机每打印一小时的磨损和零件成本。从现在起计入每次打印的成本,之前的打印不受影响。留空即关闭。',
+      dispatchPriorityLabel: '指定机型任务的优先级',
+      dispatchPriorityHelp: '当指定机型任务的打印机顺序选为按打印机优先级时使用。数字最小的先被选中,留空的排在最后。',
       fromPrinterSettings: '来自打印机设置',
       modelOptional: '型号(可选)',
       saveChanges: '保存更改',
@@ -2548,6 +2550,14 @@ export default {
     concurrentUploadsDescription: '队列可以同时向多少台打印机发送文件。打印机接收文件很慢(大型打印可能需要几分钟),并且每台都要排队等候——因此在打印机较多时,调高该值可以避免批次中最后一台打印机等完前面所有传输。如果网络或 Bambuddy 主机难以承受并行传输,请调低该值。',
     concurrentUploadsLabel: '同时上传的打印机数量',
     concurrentUploadsHelp: '设为 1 时一次只向一台打印机发送(旧行为)。默认值为 4。',
+    dispatchOrderTitle: '指定机型任务的打印机顺序',
+    dispatchOrderDescription: '当任务排队给某机型的任意打印机时,由此设置决定在能接收它的打印机中由哪一台接手。忙碌、离线或耗材不足的打印机无论顺序如何都会被跳过。',
+    dispatchOrderLabel: '选择打印机',
+    dispatchOrderFewestHours: '打印小时数最少(默认)',
+    dispatchOrderMostHours: '打印小时数最多',
+    dispatchOrderLeastRecentlyUsed: '闲置时间最长',
+    dispatchOrderPriority: '按每台打印机设置的优先级',
+    dispatchOrderHelp: '“最少”把磨损分散到整个机群。“最多”优先用掉接近更换的机器。“闲置最长”依据每台打印机最近完成的打印,从未打印过的排在最前。“按优先级”遵循每台打印机设置里的优先级字段:数字小的在前,没有数值的在最后。',
     staggeredStart: '错峰启动',
     staggeredStartDescription: '错峰启动多台打印机批次时的默认组大小和间隔。可在打印对话框中按批次覆盖。',
     preheatTitle: '预热与热保温',

+ 10 - 0
frontend/src/i18n/locales/zh-TW.ts

@@ -650,6 +650,8 @@ export default {
       autoArchiveLabel: '自動歸檔已完成的列印',
       wearCostLabel: '每列印小時磨損成本({{currency}})',
       wearCostHelp: '這台印表機每列印一小時的磨損與零件成本。從現在起計入每次列印的成本,先前的列印不受影響。留空即關閉。',
+      dispatchPriorityLabel: '指定機型任務的優先順序',
+      dispatchPriorityHelp: '當指定機型任務的列印機順序選為依列印機優先順序時使用。數字最小的先被選中,留空的排在最後。',
       fromPrinterSettings: '來自印表機設定',
       modelOptional: '型號(可選)',
       saveChanges: '儲存更改',
@@ -2548,6 +2550,14 @@ export default {
     concurrentUploadsDescription: '佇列可同時向多少台印表機傳送檔案。印表機接收檔案的速度很慢(大型列印可能需要數分鐘),而且每台都得排隊等候——因此在印表機較多時,調高此值可避免批次中最後一台印表機等完前面所有傳輸。若網路或 Bambuddy 主機難以負荷並行傳輸,請調低此值。',
     concurrentUploadsLabel: '同時上傳的印表機數量',
     concurrentUploadsHelp: '設為 1 時一次只傳送給一台印表機(舊行為)。預設值為 4。',
+    dispatchOrderTitle: '指定機型任務的列印機順序',
+    dispatchOrderDescription: '當任務排隊給某機型的任一列印機時,由此設定決定能接收它的列印機中由哪一台接手。忙碌、離線或耗材不足的列印機無論順序如何都會被跳過。',
+    dispatchOrderLabel: '選擇列印機',
+    dispatchOrderFewestHours: '列印時數最少(預設)',
+    dispatchOrderMostHours: '列印時數最多',
+    dispatchOrderLeastRecentlyUsed: '閒置時間最長',
+    dispatchOrderPriority: '依每台列印機設定的優先順序',
+    dispatchOrderHelp: '「最少」把磨損分散到整個機群。「最多」優先用掉接近更換的機器。「閒置最長」依據每台列印機最近完成的列印,從未列印過的排在最前。「依優先順序」遵循每台列印機設定裡的優先順序欄位:數字小的在前,沒有數值的在最後。',
     staggeredStart: '錯開啟動',
     staggeredStartDescription: '多台印表機批次啟動時的預設群組大小與間隔。可在列印對話框中逐批覆寫。',
     preheatTitle: '預熱與熱保溫',

+ 20 - 0
frontend/src/pages/PrintersPage.tsx

@@ -8678,6 +8678,7 @@ function EditPrinterModal({
     auto_archive: printer.auto_archive,
     is_active: printer.is_active,
     wear_cost_per_hour: printer.wear_cost_per_hour ? String(printer.wear_cost_per_hour) : '',
+    dispatch_priority: printer.dispatch_priority != null ? String(printer.dispatch_priority) : '',
   });
   const { data: settings } = useUiSettings();
   const currency = getCurrencySymbol(settings?.currency || 'USD');
@@ -8736,6 +8737,8 @@ function EditPrinterModal({
       is_active: form.is_active,
       // Empty or 0 turns wear cost off for this printer (#694)
       wear_cost_per_hour: Number(form.wear_cost_per_hour) > 0 ? Number(form.wear_cost_per_hour) : null,
+      // Empty clears it; 0 is a real place (first) (#2915)
+      dispatch_priority: form.dispatch_priority.trim() === '' ? null : Math.max(0, Math.round(Number(form.dispatch_priority)) || 0),
     };
     // Only include access_code if it was changed
     if (form.access_code) {
@@ -8903,6 +8906,23 @@ function EditPrinterModal({
               />
               <p className="text-xs text-bambu-gray mt-1">{t('printers.modal.wearCostHelp')}</p>
             </div>
+            <div>
+              <label htmlFor="edit_dispatch_priority" className="block text-sm text-bambu-gray mb-1">
+                {t('printers.modal.dispatchPriorityLabel', 'Priority for any-model jobs')}
+              </label>
+              <input
+                id="edit_dispatch_priority"
+                type="number"
+                min={0}
+                step={1}
+                inputMode="numeric"
+                className="w-full px-3 py-2 bg-bambu-dark border border-bambu-dark-tertiary rounded-lg text-white focus:border-bambu-green focus:outline-none"
+                value={form.dispatch_priority}
+                onChange={(e) => setForm({ ...form, dispatch_priority: e.target.value })}
+                placeholder="-"
+              />
+              <p className="text-xs text-bambu-gray mt-1">{t('printers.modal.dispatchPriorityHelp')}</p>
+            </div>
             {/* Maintenance Mode toggle (#1476) — checkbox is the inverse of
                 is_active because the user-facing concept is "is this printer
                 in maintenance" not "is it active". */}

+ 72 - 32
frontend/src/pages/SettingsPage.tsx

@@ -19,7 +19,7 @@ import {
 import { describeHASensorReading, iconForHASensor } from '../utils/haSensorDisplay';
 import { SECRET_PLACEHOLDER, secretsToReenter, selectPlaceholderOnFocus } from '../utils/secrets';
 import { PreheatFilamentTargetsEditor } from '../components/PreheatFilamentTargetsEditor';
-import type { Printer as PrinterInfo, APIKey, AppSettings, AppSettingsUpdate, PrinterHASensor, LocationHASensor, LocationHASensorReading, SmartPlug, SmartPlugStatus, NotificationProvider, NotificationTemplate, UpdateStatus, GitHubBackupStatus, CloudAuthStatus, UserCreate, UserUpdate, UserResponse, StorageUsageResponse, CalibrationMode } from '../api/client';
+import type { Printer as PrinterInfo, APIKey, AppSettings, AppSettingsUpdate, PrinterHASensor, LocationHASensor, LocationHASensorReading, SmartPlug, SmartPlugStatus, NotificationProvider, NotificationTemplate, UpdateStatus, GitHubBackupStatus, CloudAuthStatus, UserCreate, UserUpdate, UserResponse, StorageUsageResponse, CalibrationMode, ModelDispatchOrder } from '../api/client';
 import { Card, CardContent, CardDensityProvider, CardHeader } from '../components/Card';
 import { SlicerPipelinesPanel } from '../components/SlicerPipelinesPanel';
 import { CameraTokensSection } from './CameraTokensPage';
@@ -98,6 +98,7 @@ registerSettingsSearch({ labelKey: 'settings.defaultPrintOptions', labelFallback
 registerSettingsSearch({ labelKey: 'settings.tempFanPresetsTitle', labelFallback: 'Temperature & Fan Presets', tab: 'queue', keywords: 'temperature fan presets nozzle bed chamber quick buttons popover', anchor: 'card-temp-fan-presets' });
 registerSettingsSearch({ labelKey: 'settings.staggeredStart', labelFallback: 'Staggered Start', tab: 'queue', keywords: 'staggered batch delay start queue group', anchor: 'card-staggered' });
 registerSettingsSearch({ labelKey: 'settings.plateClear', labelFallback: 'Plate-Clear Confirmation', tab: 'queue', keywords: 'plate clear confirm auto queue', anchor: 'card-plate' });
+registerSettingsSearch({ labelKey: 'settings.dispatchOrderTitle', labelFallback: 'Printer Order for Any-Model Jobs', tab: 'queue', keywords: 'printer order any model dispatch pick wear hours least recently used idle priority farm balance', anchor: 'card-dispatch-order' });
 registerSettingsSearch({ labelKey: 'settings.concurrentUploadsTitle', labelFallback: 'Concurrent Uploads', tab: 'queue', keywords: 'concurrent parallel upload transfer ftp queue slow farm simultaneous', anchor: 'card-concurrent-uploads' });
 registerSettingsSearch({ labelKey: 'settings.gcodeInjection', labelFallback: 'G-code Injection', tab: 'queue', keywords: 'gcode injection start end autoprint farmloop swapmod autoclear printflow', anchor: 'card-gcode' });
 registerSettingsSearch({ labelKey: 'settings.slicerCard', labelFallback: 'Slicer', tab: 'queue', keywords: 'slicer orcaslicer bambustudio orca bambu api sidecar url docker preferred', anchor: 'card-slicer' });
@@ -1358,6 +1359,7 @@ export function SettingsPage() {
       (baseline.stagger_interval_minutes ?? 5) !== (localSettings.stagger_interval_minutes ?? 5) ||
       (baseline.require_plate_clear ?? false) !== (localSettings.require_plate_clear ?? false) ||
       (baseline.queue_max_concurrent_uploads ?? 4) !== (localSettings.queue_max_concurrent_uploads ?? 4) ||
+      (baseline.model_dispatch_order ?? 'fewest_hours') !== (localSettings.model_dispatch_order ?? 'fewest_hours') ||
       (baseline.preheat_enabled ?? false) !== (localSettings.preheat_enabled ?? false) ||
       (baseline.preheat_filament_targets ?? '') !== (localSettings.preheat_filament_targets ?? '') ||
       (baseline.preheat_max_wait_seconds ?? 900) !== (localSettings.preheat_max_wait_seconds ?? 900) ||
@@ -1487,6 +1489,7 @@ export function SettingsPage() {
         stagger_interval_minutes: localSettings.stagger_interval_minutes,
         require_plate_clear: localSettings.require_plate_clear,
         queue_max_concurrent_uploads: localSettings.queue_max_concurrent_uploads,
+        model_dispatch_order: localSettings.model_dispatch_order,
         preheat_enabled: localSettings.preheat_enabled,
         preheat_filament_targets: localSettings.preheat_filament_targets,
         preheat_max_wait_seconds: localSettings.preheat_max_wait_seconds,
@@ -5474,37 +5477,6 @@ export function SettingsPage() {
             </CardContent>
           </Card>
 
-          {/* Concurrent queue uploads (#2555) */}
-          <Card id="card-concurrent-uploads">
-            <CardHeader>
-              <h3 className="text-base font-semibold text-white flex items-center gap-2">
-                <UploadCloud className="w-4 h-4 text-bambu-green" />
-                {t('settings.concurrentUploadsTitle', 'Concurrent Uploads')}
-              </h3>
-            </CardHeader>
-            <CardContent className="space-y-3">
-              <p className="text-xs text-bambu-gray">
-                {t('settings.concurrentUploadsDescription', 'How many printers the queue may send files to at the same time. Printers receive files slowly (a large print can take several minutes), and each one waits its turn — so on a bigger fleet, raising this is what stops the last printer in a batch from waiting out every transfer before it. Lower it if your network or Bambuddy host struggles with parallel transfers.')}
-              </p>
-              <div className="w-full sm:w-1/2">
-                <label className="block text-xs text-bambu-gray mb-1">
-                  {t('settings.concurrentUploadsLabel', 'Printers uploaded to at once')}
-                </label>
-                <NumberInput
-                  min={1}
-                  max={16}
-                  value={localSettings.queue_max_concurrent_uploads ?? 4}
-                  onChange={(v) => updateSetting('queue_max_concurrent_uploads', v)}
-                  fallback={1}
-                  className="w-full px-3 py-2 bg-bambu-dark border border-bambu-dark-tertiary rounded-lg text-white text-sm focus:outline-none focus:border-bambu-green"
-                />
-                <p className="text-xs text-bambu-gray mt-1">
-                  {t('settings.concurrentUploadsHelp', '1 sends to one printer at a time (the old behaviour). Default is 4.')}
-                </p>
-              </div>
-            </CardContent>
-          </Card>
-
           {/* Preheat & Heat Soak (#1468) */}
           <Card id="card-preheat">
             <CardHeader>
@@ -6333,6 +6305,74 @@ export function SettingsPage() {
               })()}
             </CardContent>
           </Card>
+
+          {/* Printer order for any-model jobs (#2915) */}
+          <Card id="card-dispatch-order">
+            <CardHeader>
+              <h3 className="text-base font-semibold text-white flex items-center gap-2">
+                <ListOrdered className="w-4 h-4 text-bambu-green" />
+                {t('settings.dispatchOrderTitle', 'Printer Order for Any-Model Jobs')}
+              </h3>
+            </CardHeader>
+            <CardContent className="space-y-3">
+              <p className="text-xs text-bambu-gray">
+                {t('settings.dispatchOrderDescription', 'When a job is queued for any printer of a model, this decides which of the printers that can take it gets it. A printer that is busy, offline or short of filament is passed over, whatever the order.')}
+              </p>
+              <div className="w-full sm:w-1/2">
+                <label htmlFor="model_dispatch_order" className="block text-xs text-bambu-gray mb-1">
+                  {t('settings.dispatchOrderLabel', 'Pick the printer')}
+                </label>
+                <div className="relative">
+                  <select
+                    id="model_dispatch_order"
+                    value={localSettings.model_dispatch_order ?? 'fewest_hours'}
+                    onChange={(e) => updateSetting('model_dispatch_order', e.target.value as ModelDispatchOrder)}
+                    className="w-full px-3 py-2 pr-10 bg-bambu-dark border border-bambu-dark-tertiary rounded-lg text-white text-sm focus:border-bambu-green focus:outline-none appearance-none cursor-pointer"
+                  >
+                    <option value="fewest_hours">{t('settings.dispatchOrderFewestHours', 'With the fewest print hours (default)')}</option>
+                    <option value="most_hours">{t('settings.dispatchOrderMostHours', 'With the most print hours')}</option>
+                    <option value="least_recently_used">{t('settings.dispatchOrderLeastRecentlyUsed', 'Idle the longest')}</option>
+                    <option value="priority">{t('settings.dispatchOrderPriority', 'By the priority set on each printer')}</option>
+                  </select>
+                  <ChevronDown className="absolute right-3 top-1/2 -translate-y-1/2 w-4 h-4 text-bambu-gray pointer-events-none" />
+                </div>
+              </div>
+              <p className="text-xs text-bambu-gray mt-1">
+                {t('settings.dispatchOrderHelp', "Fewest hours spreads the wear over the farm. Most hours uses up the machines near replacement first. Idle the longest goes by each printer's last finished print, and one that never printed goes first. By priority follows the Priority field in each printer's settings: the lowest number first, printers without one last.")}
+              </p>
+            </CardContent>
+          </Card>
+
+          {/* Concurrent queue uploads (#2555) */}
+          <Card id="card-concurrent-uploads">
+            <CardHeader>
+              <h3 className="text-base font-semibold text-white flex items-center gap-2">
+                <UploadCloud className="w-4 h-4 text-bambu-green" />
+                {t('settings.concurrentUploadsTitle', 'Concurrent Uploads')}
+              </h3>
+            </CardHeader>
+            <CardContent className="space-y-3">
+              <p className="text-xs text-bambu-gray">
+                {t('settings.concurrentUploadsDescription', 'How many printers the queue may send files to at the same time. Printers receive files slowly (a large print can take several minutes), and each one waits its turn — so on a bigger fleet, raising this is what stops the last printer in a batch from waiting out every transfer before it. Lower it if your network or Bambuddy host struggles with parallel transfers.')}
+              </p>
+              <div className="w-full sm:w-1/2">
+                <label className="block text-xs text-bambu-gray mb-1">
+                  {t('settings.concurrentUploadsLabel', 'Printers uploaded to at once')}
+                </label>
+                <NumberInput
+                  min={1}
+                  max={16}
+                  value={localSettings.queue_max_concurrent_uploads ?? 4}
+                  onChange={(v) => updateSetting('queue_max_concurrent_uploads', v)}
+                  fallback={1}
+                  className="w-full px-3 py-2 bg-bambu-dark border border-bambu-dark-tertiary rounded-lg text-white text-sm focus:outline-none focus:border-bambu-green"
+                />
+                <p className="text-xs text-bambu-gray mt-1">
+                  {t('settings.concurrentUploadsHelp', '1 sends to one printer at a time (the old behaviour). Default is 4.')}
+                </p>
+              </div>
+            </CardContent>
+          </Card>
           </div>
         </div>
           )}