fix(placement): judge every build item, not every object id (#93)

CHANGELOG.md

@@ -9,6 +9,10 @@ All notable changes to this project are documented here. The format is based on
 ### Changed
 - **Print risk signals replace the readiness percentage.** The "Print readiness (estimate)" percentage, the star rating and the Studio score are gone. Studio now lists each risk it found, once per condition, with what it means and what to do, and says what it did and did not check. Community guidance attaches only to the conditions it actually fits.
 
+### Fixed
+- Object placement judges each placed copy of a repeated object on its own, so a copy that hangs off the plate is no longer hidden by one that does not (#93).
+- Placement and plate-fit checks are withheld (reported as not checked) for projects whose physical size the file does not establish: a non-millimetre unit, or a rotated or scaled object.
+
 ## [1.6.0] - 2026-10-21
 
 **A job you can pick up again, sizes Studio will not guess, and more projects that prepare.**

backend/snapstudio_api/service.py

@@ -585,7 +585,10 @@ def prepare_placed(path: str, out_dir: str | None = None) -> dict:
             changes=[{"key": "object placement", "old": "off the U1 plate",
                       "new": change.get("detail"), "reason": change.get("kept")}
                      for change in (result.get("changes") or [])],
-            findings=[{"title": f"Object {item.get('object_id')} outside the plate",
+            findings=[{"title": (f"Object {item.get('object_id')}, instance "
+                                 f"{(item.get('instance_index') or 0) + 1} of {item['instance_count']} "
+                                 "outside the plate" if (item.get("instance_count") or 1) > 1
+                                 else f"Object {item.get('object_id')} outside the plate"),
                        "detail": item.get("edges") and f"past the {item['edges']} edge"}
                       for item in (before.get("off_plate") or [])],
             validated=not ((result.get("after") or {}).get("off_plate")))
@@ -778,17 +781,8 @@ def preflight(path: str, host: str | None = None, port: int = 7125,
         facts["nozzle_revision"] = resolved["revision"]
         facts["nozzle_storage_error"] = resolved["storage_error"]
 
-    bed = None
-    dims = facts.get("bed_mm") or {}
-    if dims.get("x") and dims.get("y"):
-        bed = {"min_x": 0.0, "min_y": 0.0,
-               "max_x": float(dims["x"]), "max_y": float(dims["y"])}
     try:
-        # Name the plate after whatever supplied it, so a summary never describes a
-        # live bed as though it were the U1's.
-        placement = plate_placement.assess(
-            path, bed=bed,
-            bed_name=("this printer's" if bed else None))
+        placement = _assess_against(path, _placement_target(facts))
     except Exception:
         placement = None
 
@@ -2697,41 +2691,102 @@ def batch_status(job_id: str) -> dict | None:
 _ready_cache_lock = threading.Lock()
 
 
-def _ready_analysis(path: str, bed: dict | None,
+def _placement_target(facts: dict) -> dict | None:
+    """The printable area to judge placement against, or None when it is not known.
+
+    A connected printer reports the toolhead's AXIS TRAVEL (about 271 x 335 on a U1, whose plate is
+    270 x 270), which is not a printable area and is never used as one. What is used instead:
+    the U1's printable polygon when the machine identifies itself as the U1, or the recorded
+    printable volume of the profile it identifies as. A printer Studio cannot identify has no known
+    printable area: None, and the bed check says so rather than guessing.
+    """
+    from snapstudio_core import printer_profiles
+
+    printer_id = (facts.get("identity") or {}).get("printer_id")
+    if not printer_id:
+        return None
+    if printer_id == printer_profiles.PREPARE_TARGET_ID:
+        return {"key": ("profile", printer_id), "bed": None, "name": None, "height": None}
+    try:
+        profile = printer_profiles.load(printer_id)
+        volume = profile.get("build_volume_mm") or {}
+    except KeyError:
+        return None
+    if not (volume.get("x") and volume.get("y")):
+        return None
+    return {"key": ("profile", printer_id, float(volume["x"]), float(volume["y"])),
+            "bed": {"min_x": 0.0, "min_y": 0.0, "max_x": float(volume["x"]), "max_y": float(volume["y"])},
+            "name": f"the {printer_profiles.display_name(profile)}'s", "height": float(volume["z"]) if volume.get("z") else None}
+
+
+def _assess_against(path: str, target: dict | None) -> dict | None:
+    from snapstudio_core import plate_placement
+
+    if target is None:
+        return None
+    return plate_placement.assess(path, bed=target["bed"], bed_name=target["name"],
+                                  height_mm=target["height"])
+
+
+_READY_ATTEMPTS = 3
+
+
+def _ready_analysis(path: str, target: dict | None,
                     need_placement: bool = True) -> tuple[str, dict | None, dict | None]:
     """(file_state, traits, placement) for one file, cached by what was read.
 
-    Keyed by path, mtime_ns, size and the bed it was placed against, so an edited
-    file or a different printer bed is analysed again and nothing else is.
+    The file is identified before it is read and again after: if it changed in between, what was
+    read may mix two versions, so it is discarded and read again (a few times at most). A file that
+    will not hold still is reported as unreadable this time and nothing about it is cached.
+    """
+    for _attempt in range(_READY_ATTEMPTS):
+        outcome = _ready_analysis_once(path, target, need_placement)
+        if outcome is not None:
+            return outcome
+    return "unreadable", None, None
+
+
+def _ready_analysis_once(path: str, target: dict | None, need_placement: bool):
+    """One pass of `_ready_analysis`; None when the file changed while it was being read.
+
+    Keyed by the file's content fingerprint (and the printable area it was placed against), so an
+    edited file or a different printer is analysed again and nothing else is.
 
     Placement (a full read of the model's geometry) is by far the slowest step, so it
     is only done when asked for: `need_placement=False` returns the cheap traits and
     leaves placement None, and a later `True` call fills it in on the same cache entry.
     """
-    from snapstudio_core import plate_placement, project_traits
+    from snapstudio_core import fileid, plate_placement, project_traits
 
     try:
         st = os.stat(path)
     except OSError:
         return "missing", None, None
-    bed_key = (bed["max_x"], bed["max_y"]) if bed else None
-    key = (path, st.st_mtime_ns, st.st_size, bed_key)
+    # the content fingerprint is part of the key: a same-size replacement that kept its timestamp
+    # must not be served a placement computed for the old content
+    identity = fileid.file_identity(path)
+    if identity is None:
+        return "missing", None, None
+    key = (identity, target["key"] if target else None)
     with _ready_cache_lock:
         hit = _READY_CACHE.get(key)
     if hit is None:
         traits = project_traits.extract(path)
         hit = {"state": "ok" if traits.get("readable") else "unreadable", "traits": traits,
                "placement": None, "placed": False}
     foreign = (hit["traits"].get("foreign_printer") or {}).get("value") is True
-    if need_placement and not hit["placed"] and hit["state"] == "ok" and bed and not foreign:
+    if need_placement and not hit["placed"] and hit["state"] == "ok" and target and not foreign:
         # Work on a copy so concurrent scans never mutate a shared entry. A failed read is
         # not cached as done: it is unknown this time and tried again next scan.
         hit = dict(hit)
         try:
-            hit["placement"] = plate_placement.assess(path, bed=bed, bed_name="this printer's")
-            hit["placed"] = True
+            hit["placement"] = _assess_against(path, target)
+            # an unavailable result (unreadable, too large) is not "done": it is tried again next scan
+            hit["placed"] = bool(hit["placement"] and hit["placement"].get("available"))
         except Exception:
             hit["placement"] = None
+    if fileid.file_identity(path) != identity:
+        return None          # replaced while it was being read: never cache or return a mix
     with _ready_cache_lock:
         if key not in _READY_CACHE and len(_READY_CACHE) >= _READY_CACHE_MAX:
             _READY_CACHE.pop(next(iter(_READY_CACHE)), None)  # oldest first
@@ -2744,21 +2799,21 @@ def _ready_analysis(path: str, bed: dict | None,
 _PLACEMENT_MATTERS = ("cant_determine", "one_change_away", "ready_now")
 
 
-def _ready_one(row: dict, printer: dict, bed: dict | None) -> dict:
+def _ready_one(row: dict, printer: dict, target: dict | None) -> dict:
     from snapstudio_core import preflight as pf
     from snapstudio_core import readiness
 
     project = {"path": row.get("source_path"), "name": row.get("name")}
     try:
-        state, traits, placement = _ready_analysis(project["path"], bed, need_placement=False)
+        state, traits, placement = _ready_analysis(project["path"], target, need_placement=False)
         foreign = ((traits or {}).get("foreign_printer") or {}).get("value") is True
         usable = state == "ok" and printer.get("reachable") and not foreign
         pre = pf.evaluate(traits, printer, placement) if usable else None
         result = readiness.classify_project(project, traits, printer, pre, state)
-        if usable and bed and result.get("bucket") in _PLACEMENT_MATTERS:
+        if usable and target and result.get("bucket") in _PLACEMENT_MATTERS:
             # Only now is the (slow) geometry read worth it, and it can only make the
             # result stricter, never claim more than the cheap pass did.
-            state, traits, placement = _ready_analysis(project["path"], bed, need_placement=True)
+            state, traits, placement = _ready_analysis(project["path"], target, need_placement=True)
             pre = pf.evaluate(traits, printer, placement)
             result = readiness.classify_project(project, traits, printer, pre, state)
         return result
@@ -2804,13 +2859,11 @@ def worker() -> None:
             printer = printer_facts(host, port) if host else {"reachable": False}
             printer = _with_providers(printer, host, port, url, slot_map, slot_base, kind,
                                       provider_key)
-            dims = printer.get("bed_mm") or {}
-            bed = ({"min_x": 0.0, "min_y": 0.0, "max_x": float(dims["x"]),
-                    "max_y": float(dims["y"])} if dims.get("x") and dims.get("y") else None)
+            target = _placement_target(printer)
 
             results: list[dict] = []
             for row in rows:
-                results.append(_ready_one(row, printer, bed))
+                results.append(_ready_one(row, printer, target))
                 publish(progress={"done": len(results), "total": len(rows)},
                         result={"results": list(results)})
             results.sort(key=readiness.sort_key)  # stable: newest first within a bucket

backend/snapstudio_core/assignments.py

@@ -66,6 +66,16 @@
     "negative_part": NEGATIVE,
     "support_enforcer": SUPPORT_ENFORCER,
     "support_blocker": SUPPORT_BLOCKER,
+    # Orca's precise-seam helper volumes (written by Orca 2.4.2 and later). Like a modifier they steer the
+    # slicer and print nothing, so they are the modifier role. The strings are taken from Orca's own
+    # subtype list as reported to us; Snapmaker Orca 2.4.0 may not write them, and they are treated as
+    # known helper roles regardless. Any other word stays unknown (and so counts), see ``roles``.
+    "precise_seam_center": MODIFIER,
+    "precise_seam_left": MODIFIER,
+    "precise_seam_right": MODIFIER,
+    "precise_seam_enforced": MODIFIER,
+    "precise_seam_blocked": MODIFIER,
+    "precise_seam_neutral": MODIFIER,
 }
 
 #: Object-level keys that are the assignment itself or the object's identity,

backend/snapstudio_core/fileid.py

@@ -0,0 +1,46 @@
+"""What identifies a file's CONTENT for anything that remembers a result about it.
+
+A remembered result is only as good as its key. Size and modification time alone miss a same-size
+replacement that kept its timestamp (a copy that preserves times, a tool that rewrites in place), so the
+key also carries a fingerprint of the bytes, and a result is only stored if the file is unchanged after it
+was computed.
+"""
+from __future__ import annotations
+
+import hashlib
+import zipfile
+from pathlib import Path
+
+
+def stat_identity(path: str):
+    """``(resolved path, mtime, size)`` or None."""
+    try:
+        resolved = Path(path).resolve()
+        st = resolved.stat()
+    except OSError:
+        return None
+    return (str(resolved), st.st_mtime_ns, st.st_size)
+
+
+def file_identity(path: str):
+    """The stat identity PLUS a fingerprint of the content, or None if the file cannot be read.
+
+    For a zip (every 3MF) the fingerprint is taken from the archive's own directory: each member's name,
+    size and CRC-32, which changes whenever any member's bytes do and costs a read of the directory only,
+    not of a 40 MB project. Anything else is hashed whole."""
+    base = stat_identity(path)
+    if base is None:
+        return None
+    digest = hashlib.blake2b(digest_size=16)
+    try:
+        try:
+            with zipfile.ZipFile(path) as archive:
+                for info in archive.infolist():
+                    digest.update(f"{info.filename}|{info.file_size}|{info.CRC}|".encode("utf-8", "replace"))
+        except zipfile.BadZipFile:
+            with open(path, "rb") as fh:
+                for chunk in iter(lambda: fh.read(1 << 20), b""):
+                    digest.update(chunk)
+    except OSError:
+        return None
+    return base + (digest.hexdigest(),)