@camstack/addon-pipeline 1.2.621 → 1.2.623

package/python/coreml_load_probe.py

@@ -12,8 +12,11 @@ happens in a throwaway interpreter. The verdict is remembered next to the
 compiled-model cache:
 
   ok           -> load in-process, never probe this package again
-  crashed      -> refuse with `CoremlLoadCrashed` (reason `native-load-crashed`),
-                  now and on every later load, without re-probing
+  crashed      -> refuse with `CoremlLoadCrashed` (reason `native-load-crashed`)
+                  now. ONE crash is only `suspect` (D926): refused without
+                  probing for a cool-off, then probed again. A SECOND crash
+                  at least a cool-off after the first caches `crashed`, refused
+                  on every later load without re-probing; an `ok` resets.
   inconclusive -> (a Python exception in the child, a probe past its bound, a
                   child that could not start) remembered NOWHERE; the
                   in-process load runs exactly as it did before this gate
@@ -33,6 +36,7 @@ import platform
 import signal
 import subprocess
 import sys
+import time
 from typing import Callable, Optional
 
 # One-way: inference_pool imports this module lazily, inside its CoreML branch.
@@ -43,6 +47,63 @@ VERDICT_CRASHED = "crashed"
 VERDICT_INCONCLUSIVE = "inconclusive"
 
 PROBE_VERDICT_VERSION = 1
+
+# The two-crash rule, shared with `openvino_compile_probe` (D926, D49): one
+# native crash is `suspect`; this many crashes, the last at least a cool-off
+# after the first, is `crashed` and cached for good. A v1 `crashed` record
+# (no `crashes` list) reads as ONE crash of unknown age, so it is re-probed.
+VERDICT_SUSPECT = "suspect"
+CRASHES_TO_CONFIRM = 2
+CRASH_COOL_OFF_SEC = 600.0
+
+Clock = Callable[[], float]
+LoadAvg = Callable[[], "tuple[float, float, float]"]
+
+
+def host_loadavg() -> "tuple[float, float, float]":
+    try:
+        return os.getloadavg()
+    except (OSError, AttributeError):  # Windows has no load average
+        return (-1.0, -1.0, -1.0)
+
+
+def crash_at(crash: object) -> float:
+    if isinstance(crash, dict):
+        at = crash.get("at")
+        if isinstance(at, (int, float)):
+            return float(at)
+    return 0.0
+
+
+def crashes_confirmed(crashes: list) -> bool:
+    """Two crashes (or more), the last at least a cool-off after the first."""
+    if len(crashes) < CRASHES_TO_CONFIRM:
+        return False
+    return crash_at(crashes[-1]) - crash_at(crashes[0]) >= CRASH_COOL_OFF_SEC
+
+
+def normalise_crash_record(stored: dict) -> Optional[dict]:
+    """A stored verdict with its crash list filled in; an unconfirmed `crashed` reads `suspect`."""
+    verdict = stored.get("verdict")
+    if verdict not in (VERDICT_OK, VERDICT_CRASHED, VERDICT_SUSPECT):
+        return None
+    if verdict == VERDICT_OK:
+        return stored
+    crashes = stored.get("crashes")
+    if not isinstance(crashes, list) or not crashes:
+        crashes = [{"at": 0.0, "loadavg": None, "detail": str(stored.get("detail") or "")}]
+    out = {**stored, "crashes": crashes}
+    if verdict == VERDICT_CRASHED and not crashes_confirmed(crashes):
+        out = {**out, "verdict": VERDICT_SUSPECT}
+    return out
+
+
+def record_crash(
+    prior: list, detail: str, now: float, load: "tuple[float, float, float]",
+) -> "tuple[str, list]":
+    """Append one crash; return the verdict to store (`suspect` or `crashed`) and the list."""
+    crashes = [*prior, {"at": now, "loadavg": [round(x, 2) for x in load], "detail": detail}]
+    return (VERDICT_CRASHED if crashes_confirmed(crashes) else VERDICT_SUSPECT), crashes
 PROBE_MARKER = "@@CAMSTACK_COREML_PROBE_OK@@"
 # Long enough for the slowest cold compile measured on a Mac (rfdetr-package,
 # 58 s); the pool's own load bound reports a slow load to the host meanwhile.
@@ -169,18 +230,21 @@ def _read_verdict(path: str, key: dict) -> Optional[dict]:
         return None
     if not isinstance(stored, dict) or stored.get("key") != key:
         return None
-    if stored.get("verdict") not in (VERDICT_OK, VERDICT_CRASHED):
-        return None
-    return stored
+    return normalise_crash_record(stored)
 
 
-def _write_verdict(path: str, key: dict, verdict: str, detail: str) -> None:
+def _write_verdict(
+    path: str, key: dict, verdict: str, detail: str, crashes: "Optional[list]" = None,
+) -> None:
     """Atomic replace; a verdict that cannot be written only costs a re-probe."""
     tmp = f"{path}.tmp-{os.getpid()}"
+    record: dict = {"key": key, "verdict": verdict, "detail": detail}
+    if crashes:
+        record["crashes"] = crashes
     try:
         os.makedirs(os.path.dirname(path), exist_ok=True)
         with open(tmp, "w", encoding="utf-8") as fh:
-            json.dump({"key": key, "verdict": verdict, "detail": detail}, fh)
+            json.dump(record, fh)
         os.replace(tmp, path)
     except OSError as exc:
         sys.stderr.write(f"CoreML probe: could not persist the verdict for {path} ({exc})\n")
@@ -196,8 +260,11 @@ def ensure_coreml_loadable(
     device: str,
     run: Optional[ProbeRunner] = None,
     os_build: Optional[str] = None,
+    now: Optional[Clock] = None,
+    loadavg: Optional[LoadAvg] = None,
 ) -> None:
     """Return when `model_path` may be loaded in-process; raise when it would crash."""
+    clock = now if now is not None else time.time
     key = {
         "version": PROBE_VERDICT_VERSION,
         "fingerprint": _coreml_model_fingerprint(model_path),  # a re-download is a new package
@@ -207,17 +274,40 @@ def ensure_coreml_loadable(
     verdict_path = probe_verdict_path(model_path, device)
     known = _read_verdict(verdict_path, key)
     name = os.path.basename(model_path)
+    prior_crashes: list = []
     if known is not None:
         if known["verdict"] == VERDICT_CRASHED:
-            sys.stderr.write(f"CoreML probe: {name} device={device} is a KNOWN loader crash — refused\n")
-            sys.stderr.flush()
+            _log(f"{name} device={device} is a KNOWN loader crash "
+                 f"({len(known['crashes'])} crashes) — refused")
             raise CoremlLoadCrashed(model_path, device, str(known.get("detail") or "known crash"))
-        return
+        if known["verdict"] == VERDICT_OK:
+            return
+        prior_crashes = list(known["crashes"])
+        retry_at = crash_at(prior_crashes[-1]) + CRASH_COOL_OFF_SEC
+        if clock() < retry_at:
+            _log(f"{name} device={device} crashed the loader once — refused until the "
+                 f"cool-off ends ({retry_at - clock():.0f}s left)")
+            raise CoremlLoadCrashed(
+                model_path, device,
+                f"{known.get('detail') or 'one crash'}; one crash so far, "
+                f"re-probed after {CRASH_COOL_OFF_SEC:g}s",
+            )
     runner = run if run is not None else DEFAULT_RUNNER
     verdict, detail = runner(model_path, device)
-    sys.stderr.write(f"CoreML probe: {name} device={device} -> {verdict} ({detail})\n")
-    sys.stderr.flush()
-    if verdict in (VERDICT_OK, VERDICT_CRASHED):
+    _log(f"{name} device={device} -> {verdict} ({detail})")
+    if verdict == VERDICT_OK:
         _write_verdict(verdict_path, key, verdict, detail)
-    if verdict == VERDICT_CRASHED:
-        raise CoremlLoadCrashed(model_path, device, detail)
+        return
+    if verdict != VERDICT_CRASHED:
+        return  # inconclusive: remembered nowhere; an earlier suspect stands
+    load = (loadavg if loadavg is not None else host_loadavg)()
+    stored, crashes = record_crash(prior_crashes, detail, clock(), load)
+    _log(f"{name} device={device} loader crash {len(crashes)}/{CRASHES_TO_CONFIRM} "
+         f"(load {load[0]:.1f}) -> {stored}")
+    _write_verdict(verdict_path, key, stored, detail, crashes)
+    raise CoremlLoadCrashed(model_path, device, detail)
+
+
+def _log(line: str) -> None:
+    sys.stderr.write(f"CoreML probe: {line}\n")
+    sys.stderr.flush()

package/python/inference_pool.py

@@ -3150,7 +3150,21 @@ async def _run() -> None:
     )
     sys.stderr.flush()
 
-    await writer.send(req_id, {
+    # Compute the estimate scales from (D930). A failed probe is omitted —
+    # never a row of zeros — and must not delay `ready`.
+    accelerator_facts = None
+    try:
+        from accelerator_facts import facts_for_runtime, publish_accelerator_facts
+
+        accelerator_facts = facts_for_runtime(runtime, _runtime_lib, pool_device)
+        if accelerator_facts:
+            publish_accelerator_facts(accelerator_facts)
+    except Exception as exc:
+        sys.stderr.write(f"accelerator facts: probe failed ({exc})\n")
+        sys.stderr.flush()
+        accelerator_facts = None
+
+    ready_payload = {
         "status": "ready",
         "models": loaded_count,
         "total": len(models),
@@ -3161,7 +3175,10 @@ async def _run() -> None:
         # the same min() against what it declared, so both ends derive the
         # identical effective version (D350).
         "protocolVersion": PROTOCOL_VERSION,
-    })
+    }
+    if accelerator_facts is not None:
+        ready_payload["acceleratorFacts"] = accelerator_facts
+    await writer.send(req_id, ready_payload)
 
     # ── Window accumulator (per-model) ──────────────────────────────
     #

package/python/openvino_compile_probe.py

@@ -19,13 +19,24 @@ therefore writes the blob the pool then loads warm. Mirrors CoreML's
   ok           -> load in-process (a cache HIT), never probe this key again
                   while the blobs the probe wrote are still on disk
   crashed      -> refuse with `OpenvinoLoadCrashed` (reason
-                  `native-load-crashed`), now and on every later load of the
-                  same key, without re-probing
+                  `native-load-crashed`) now. ONE crash is only `suspect`:
+                  later loads are refused without probing until a cool-off
+                  (CRASH_COOL_OFF_SEC) has passed, then probed again. Only a
+                  SECOND crash at least a cool-off after the first caches
+                  `crashed` — refused on every later load of the same key,
+                  without re-probing. An `ok` in between resets the count.
   inconclusive -> (a Python exception in the child, a probe past its bound, a
                   child that could not start) remembered NOWHERE; the
                   in-process load runs exactly as it did before this gate
 
 Only a death by SIGNAL is a crash. CPU-only loads are never probed.
+
+Why two (2026-10-23, D926): a single SIGSEGV during an overloaded moment wrote
+`crashed`, and every later request for that model on the GPU was refused for
+good. A destructive verdict needs a second agreeing read (D49). Every crash is
+recorded with its time, the host load average and the child's detail. To
+clear a verdict by hand, delete
+`<models>/.ov-cache/<model>.<DEVICE>.ovprobe.json`.
 """
 from __future__ import annotations
 
@@ -33,17 +44,30 @@ import json
 import os
 import subprocess
 import sys
+import time
 from typing import Callable, Optional
 
 # One-way: inference_pool imports this module lazily, inside its OpenVINO branch.
+# The two-crash rule (D926) lives there too, shared by both probes.
 from coreml_load_probe import (
+    CRASH_COOL_OFF_SEC,
+    CRASHES_TO_CONFIRM,
     VERDICT_CRASHED,
     VERDICT_INCONCLUSIVE,
     VERDICT_OK,
+    VERDICT_SUSPECT,
+    Clock,
+    LoadAvg,
     _signal_name,
     classify_probe_exit,
+    crash_at,
+    host_loadavg,
+    normalise_crash_record,
+    record_crash,
 )
 
+# The key's version stays 1: a v1 `crashed` file (no `crashes` list) is read
+# as ONE crash of unknown age, so it is re-probed rather than discarded.
 PROBE_VERDICT_VERSION = 1
 PROBE_MARKER = "@@CAMSTACK_OV_PROBE_OK@@"
 # A cold iGPU compile of a large detector takes tens of seconds; past this the
@@ -178,17 +202,21 @@ def _read_verdict(path: str, key: dict) -> Optional[dict]:
         return None
     if not isinstance(stored, dict) or stored.get("key") != key:
         return None
-    if stored.get("verdict") not in (VERDICT_OK, VERDICT_CRASHED):
-        return None
-    return stored
+    return normalise_crash_record(stored)
 
 
-def _write_verdict(path: str, key: dict, verdict: str, detail: str, blobs: "list[str]") -> None:
+def _write_verdict(
+    path: str, key: dict, verdict: str, detail: str, blobs: "list[str]",
+    crashes: "Optional[list]" = None,
+) -> None:
     """Atomic replace; a verdict that cannot be written only costs a re-probe."""
     tmp = f"{path}.tmp-{os.getpid()}"
+    record: dict = {"key": key, "verdict": verdict, "detail": detail, "blobs": blobs}
+    if crashes:
+        record["crashes"] = crashes
     try:
         with open(tmp, "w", encoding="utf-8") as fh:
-            json.dump({"key": key, "verdict": verdict, "detail": detail, "blobs": blobs}, fh)
+            json.dump(record, fh)
         os.replace(tmp, path)
     except OSError as exc:
         sys.stderr.write(f"OpenVINO probe: could not persist the verdict for {path} ({exc})\n")
@@ -214,32 +242,58 @@ def ensure_openvino_loadable(
     cache_dir: Optional[str],
     env_tag: str = "",
     run: Optional[ProbeRunner] = None,
+    now: Optional[Clock] = None,
+    loadavg: Optional[LoadAvg] = None,
 ) -> None:
     """Return when `model_path` may be compiled in-process; raise when it would crash."""
     if not needs_probe(candidates):
         return
+    clock = now if now is not None else time.time
     name = os.path.basename(model_path)
     device = str(config.get("device", "AUTO"))
     key = probe_key(model_path, config, candidates, env_tag)
     verdict_path = probe_verdict_path(model_path, config, cache_dir) if cache_dir else None
+    prior_crashes: list = []
     if verdict_path is not None:
         known = _read_verdict(verdict_path, key)
         if known is not None:
             if known["verdict"] == VERDICT_CRASHED:
-                sys.stderr.write(
-                    f"OpenVINO probe: {name} device={device} is a KNOWN compiler crash — refused\n"
-                )
-                sys.stderr.flush()
+                _log(f"{name} device={device} is a KNOWN compiler crash "
+                     f"({len(known['crashes'])} crashes) — refused")
                 raise OpenvinoLoadCrashed(model_path, device, str(known.get("detail") or "known crash"))
-            if cache_dir is not None and _warm(known, cache_dir):
+            if known["verdict"] == VERDICT_SUSPECT:
+                prior_crashes = list(known["crashes"])
+                retry_at = crash_at(prior_crashes[-1]) + CRASH_COOL_OFF_SEC
+                if clock() < retry_at:
+                    _log(f"{name} device={device} crashed the compiler once — refused until "
+                         f"the cool-off ends ({retry_at - clock():.0f}s left)")
+                    raise OpenvinoLoadCrashed(
+                        model_path, device,
+                        f"{known.get('detail') or 'one crash'}; one crash so far, "
+                        f"re-probed after {CRASH_COOL_OFF_SEC:g}s",
+                    )
+            elif cache_dir is not None and _warm(known, cache_dir):
                 return  # blob present: the in-process load is a cache hit
     before = _blob_names(cache_dir) if cache_dir else set()
     runner = run if run is not None else DEFAULT_RUNNER
     verdict, detail = runner(model_path, config)
-    sys.stderr.write(f"OpenVINO probe: {name} device={device} -> {verdict} ({detail})\n")
+    _log(f"{name} device={device} -> {verdict} ({detail})")
+    if verdict == VERDICT_OK:
+        if verdict_path is not None and cache_dir is not None:
+            written = sorted(_blob_names(cache_dir) - before)
+            _write_verdict(verdict_path, key, verdict, detail, written)
+        return
+    if verdict != VERDICT_CRASHED:
+        return  # inconclusive: remembered nowhere; an earlier suspect stands
+    load = (loadavg if loadavg is not None else host_loadavg)()
+    stored, crashes = record_crash(prior_crashes, detail, clock(), load)
+    _log(f"{name} device={device} compiler crash {len(crashes)}/{CRASHES_TO_CONFIRM} "
+         f"(load {load[0]:.1f}) -> {stored}")
+    if verdict_path is not None and cache_dir is not None:
+        _write_verdict(verdict_path, key, stored, detail, [], crashes)
+    raise OpenvinoLoadCrashed(model_path, device, detail)
+
+
+def _log(line: str) -> None:
+    sys.stderr.write(f"OpenVINO probe: {line}\n")
     sys.stderr.flush()
-    if verdict in (VERDICT_OK, VERDICT_CRASHED) and verdict_path is not None and cache_dir is not None:
-        written = sorted(_blob_names(cache_dir) - before) if verdict == VERDICT_OK else []
-        _write_verdict(verdict_path, key, verdict, detail, written)
-    if verdict == VERDICT_CRASHED:
-        raise OpenvinoLoadCrashed(model_path, device, detail)

package/python/postprocessors/ssd.py

@@ -6,7 +6,9 @@ SSD MobileNet V2 and EfficientDet-Lite detectors. Those models embed the
 decoded (boxes + per-box class + score, post-NMS):
 
     output 0  boxes    [1, N, 4]  (ymin, xmin, ymax, xmax) normalised 0..1
-    output 1  classes  [1, N]     float class indices (COCO 90-class map)
+    output 1  classes  [1, N]     float class indices (COCO 90-class map,
+                                     or the model's own label list when the
+                                     descriptor carries one)
     output 2  scores   [1, N]     float 0..1
     output 3  count    [1]        number of valid detections
 
@@ -118,8 +120,10 @@ def _split_outputs(predictions: dict) -> tuple:
     return boxes, classes, scores, count
 
 
-def label_for_class(cls: int) -> str:
-    """COCO-90 label of a raw class index; ``"n/a"`` for a gap, ``str`` if outside."""
+def label_for_class(cls: int, labels: list | None = None) -> str:
+    """Class name for a raw index; default map is COCO-90 when labels is absent/empty."""
+    if labels:
+        return labels[cls] if 0 <= cls < len(labels) else str(cls)
     return COCO_90[cls] if 0 <= cls < len(COCO_90) else str(cls)
 
 
@@ -134,6 +138,10 @@ def postprocess_ssd(
     """Decode SSD/EfficientDet postprocess outputs to original-frame detections."""
     conf_threshold = float(config.get("confidence", 0.4) or 0.4)
     input_size = int(config.get("inputSize", 300) or 300)
+    raw_labels = config.get("labels")
+    label_map: list | None = (
+        list(raw_labels) if isinstance(raw_labels, list) and len(raw_labels) > 0 else None
+    )
 
     boxes, classes, scores, count = _split_outputs(predictions)
     if boxes is None or scores is None:
@@ -172,7 +180,7 @@ def postprocess_ssd(
         y2 = max(0.0, min(y2, orig_h))
         if x2 <= x1 or y2 <= y1:
             continue
-        label = label_for_class(int(classes[i]))
+        label = label_for_class(int(classes[i]), label_map)
         if label == "n/a":
             continue
         detections.append({

package/python/postprocessors/test_ssd.py

@@ -189,6 +189,70 @@ class ScoreCeilingTest(unittest.TestCase):
         self.assertEqual(len([d for d in _decode(STREET, confidence=0.65) if d["class"] == "person"]), 3)
 
 
+class ConfigLabelsTest(unittest.TestCase):
+    """Custom label maps from the pool; absent labels keep COCO-90 in Python."""
+
+    _SYNTH = {
+        "0": [[[0.1, 0.1, 0.5, 0.5]]],
+        "1": [[3.0]],
+        "2": [[0.9]],
+        "3": [1.0],
+    }
+
+    def test_custom_labels_name_classes(self) -> None:
+        # Index 3 is dog and index 29 is car — the Plus map the COCO-90 table misnames.
+        labels = ["person", "bicycle", "x", "dog"] + ["pad"] * 25 + ["car"]
+        self.assertEqual(labels[3], "dog")
+        self.assertEqual(labels[29], "car")
+        dog = postprocess_ssd(
+            self._SYNTH,
+            {"confidence": 0.4, "inputSize": 100, "labels": labels},
+            100,
+            100,
+            1.0,
+            (0, 0),
+        )["detections"]
+        self.assertEqual(len(dog), 1)
+        self.assertEqual(dog[0]["class"], "dog")
+        car_out = dict(self._SYNTH)
+        car_out["1"] = [[29.0]]
+        car = postprocess_ssd(
+            car_out,
+            {"confidence": 0.4, "inputSize": 100, "labels": labels},
+            100,
+            100,
+            1.0,
+            (0, 0),
+        )["detections"]
+        self.assertEqual(len(car), 1)
+        self.assertEqual(car[0]["class"], "car")
+
+    def test_no_labels_key_uses_coco90_and_skips_na(self) -> None:
+        out = dict(self._SYNTH)
+        out["1"] = [[29.0]]
+        dets = postprocess_ssd(
+            out,
+            {"confidence": 0.4, "inputSize": 100},
+            100,
+            100,
+            1.0,
+            (0, 0),
+        )["detections"]
+        self.assertEqual(dets, [])
+        out2 = dict(self._SYNTH)
+        out2["1"] = [[3.0]]
+        dets2 = postprocess_ssd(
+            out2,
+            {"confidence": 0.4, "inputSize": 100},
+            100,
+            100,
+            1.0,
+            (0, 0),
+        )["detections"]
+        self.assertEqual(len(dets2), 1)
+        self.assertEqual(dets2[0]["class"], "motorcycle")
+
+
 class NumpyInputTest(unittest.TestCase):
     """The pool hands ndarrays; they must decode exactly like the lists above."""
 

package/python/test_accelerator_facts.py

@@ -0,0 +1,105 @@
+"""Unit tests for accelerator compute facts (D930). No OpenVINO import."""
+import json
+import os
+import tempfile
+import unittest
+
+import accelerator_facts as facts
+
+
+class _Core:
+    def __init__(self, devices, props):
+        self.available_devices = devices
+        self._props = props
+        self.failed = set()
+
+    def get_property(self, device, name):
+        if (device, name) in self.failed:
+            raise RuntimeError(f"probe failed {device} {name}")
+        device_props = self._props.get(device, {})
+        if name not in device_props:
+            raise KeyError(name)
+        return device_props[name]
+
+
+class OpenVinoFactsTest(unittest.TestCase):
+    def test_reports_gpu_and_npu_and_null_for_a_failed_query(self):
+        core = _Core(
+            ["CPU", "GPU", "NPU"],
+            {
+                "GPU": {
+                    "FULL_DEVICE_NAME": "Intel(R) Graphics",
+                    "GPU_EXECUTION_UNITS_COUNT": 32,
+                    "GPU_DEVICE_MAX_FREQUENCY": 1250,
+                    "DEVICE_GOPS": {"i8": 400, "f16": 200},
+                    "DEVICE_ARCHITECTURE": "Xe",
+                },
+                "NPU": {
+                    "FULL_DEVICE_NAME": "Intel AI Boost",
+                    "DEVICE_ARCHITECTURE": "NPU",
+                    "NPU_MAX_TOPS": 10,
+                },
+            },
+        )
+        core.failed.add(("GPU", "DEVICE_ARCHITECTURE"))
+        rows = facts.collect_openvino_device_facts(core)
+        self.assertEqual([row["deviceKey"] for row in rows], ["openvino:gpu", "openvino:npu"])
+        gpu = rows[0]
+        self.assertEqual(gpu["executionUnits"], 32)
+        self.assertEqual(gpu["clockMHz"], 1250)
+        self.assertEqual(gpu["gops"], {"int8": 400, "fp16": 200})
+        self.assertIsNone(gpu["architecture"])
+        self.assertEqual(rows[1]["npuName"], "Intel AI Boost")
+        self.assertEqual(rows[1]["tops"], 10)
+        self.assertIsNone(rows[1]["executionUnits"])
+
+    def test_a_zero_eu_count_is_null(self):
+        core = _Core(
+            ["GPU"],
+            {"GPU": {"FULL_DEVICE_NAME": "Intel", "GPU_EXECUTION_UNITS_COUNT": 0}},
+        )
+        rows = facts.collect_openvino_device_facts(core)
+        self.assertIsNone(rows[0]["executionUnits"])
+        self.assertIsNone(rows[0]["gops"])
+
+    def test_a_failed_device_list_is_none(self):
+        class Boom:
+            @property
+            def available_devices(self):
+                raise RuntimeError("no core")
+
+        self.assertIsNone(facts.collect_openvino_device_facts(Boom()))
+
+
+class WebGpuFactsTest(unittest.TestCase):
+    def test_reads_adapter_fields_and_leaves_a_missing_cu_null(self):
+        row = facts.webgpu_facts_from_device(
+            {"vendor": "amd", "architecture": "rdna3", "device": "gfx1103"}
+        )
+        self.assertEqual(row["deviceKey"], "onnx:webgpu")
+        self.assertEqual(row["vendor"], "amd")
+        self.assertEqual(row["webgpuArchitecture"], "rdna3")
+        self.assertEqual(row["webgpuDevice"], "gfx1103")
+        self.assertIsNone(row["computeUnits"])
+        self.assertIsNone(facts.webgpu_facts_from_device(None))
+
+
+class PublishTest(unittest.TestCase):
+    def test_merges_by_device_key(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = os.path.join(directory, "facts.json")
+            facts.publish_accelerator_facts(
+                [facts.webgpu_facts_from_device({"vendor": "amd", "compute_units": 12})],
+                path,
+            )
+            gpu = facts._blank("openvino:gpu")
+            gpu["executionUnits"] = 24
+            facts.publish_accelerator_facts([gpu], path)
+            with open(path, "r", encoding="utf-8") as handle:
+                payload = json.load(handle)
+            keys = [row["deviceKey"] for row in payload["accelerators"]]
+            self.assertEqual(keys, ["onnx:webgpu", "openvino:gpu"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/test_coreml_load_probe.py

@@ -224,6 +224,89 @@ class EnsureCoremlLoadableTest(unittest.TestCase):
         self.assertEqual(len(runner.calls), 1)
 
 
+class CoremlCrashNeedsASecondAgreeingReadTest(unittest.TestCase):
+    """One native abort must not ban a package forever (D926, D49)."""
+
+    def setUp(self) -> None:
+        self._tmp = tempfile.TemporaryDirectory()
+        self.pkg = _make_mlpackage(self._tmp.name)
+        self.t = 2_000_000.0
+
+    def tearDown(self) -> None:
+        self._tmp.cleanup()
+
+    def ensure(self, runner) -> None:
+        probe.ensure_coreml_loadable(
+            self.pkg, "all", run=runner, os_build="26.2",
+            now=lambda: self.t, loadavg=lambda: (4.0, 3.0, 2.0),
+        )
+
+    def stored(self) -> dict:
+        with open(probe.probe_verdict_path(self.pkg, "all"), "r", encoding="utf-8") as fh:
+            return json.load(fh)
+
+    def test_a_single_crash_is_retried_after_the_cool_off(self) -> None:
+        with self.assertRaises(probe.CoremlLoadCrashed):
+            self.ensure(_Runner(probe.VERDICT_CRASHED, "signal 6"))
+        self.assertEqual(self.stored()["verdict"], probe.VERDICT_SUSPECT)
+        self.t += probe.CRASH_COOL_OFF_SEC + 1
+        ok = _Runner(probe.VERDICT_OK)
+        self.ensure(ok)
+        self.assertEqual(len(ok.calls), 1)
+        self.assertEqual(self.stored()["verdict"], probe.VERDICT_OK)
+
+    def test_within_the_cool_off_a_single_crash_refuses_without_probing(self) -> None:
+        crashed = _Runner(probe.VERDICT_CRASHED)
+        with self.assertRaises(probe.CoremlLoadCrashed):
+            self.ensure(crashed)
+        self.t += probe.CRASH_COOL_OFF_SEC - 1
+        with self.assertRaises(probe.CoremlLoadCrashed):
+            self.ensure(crashed)
+        self.assertEqual(len(crashed.calls), 1)
+
+    def test_two_crashes_a_cool_off_apart_are_cached(self) -> None:
+        crashed = _Runner(probe.VERDICT_CRASHED)
+        with self.assertRaises(probe.CoremlLoadCrashed):
+            self.ensure(crashed)
+        self.t += probe.CRASH_COOL_OFF_SEC + 1
+        with self.assertRaises(probe.CoremlLoadCrashed):
+            self.ensure(crashed)
+        stored = self.stored()
+        self.assertEqual(stored["verdict"], probe.VERDICT_CRASHED)
+        self.assertEqual(len(stored["crashes"]), 2)
+        self.assertEqual(stored["crashes"][0]["loadavg"], [4.0, 3.0, 2.0])
+        self.t += 10 * probe.CRASH_COOL_OFF_SEC
+        with self.assertRaises(probe.CoremlLoadCrashed):
+            self.ensure(crashed)
+        self.assertEqual(len(crashed.calls), 2)
+
+    def test_a_success_in_between_resets_the_count(self) -> None:
+        crashed = _Runner(probe.VERDICT_CRASHED)
+        with self.assertRaises(probe.CoremlLoadCrashed):
+            self.ensure(crashed)
+        self.t += probe.CRASH_COOL_OFF_SEC + 1
+        self.ensure(_Runner(probe.VERDICT_OK))
+        # An ok is remembered for good; a changed OS build is what re-probes it.
+        with open(probe.probe_verdict_path(self.pkg, "all"), "r", encoding="utf-8") as fh:
+            record = json.load(fh)
+        self.assertNotIn("crashes", record)
+
+    def test_a_legacy_single_crash_verdict_is_reprobed(self) -> None:
+        key = {
+            "version": probe.PROBE_VERDICT_VERSION,
+            "fingerprint": ip._coreml_model_fingerprint(self.pkg),
+            "device": "all",
+            "os": "26.2",
+        }
+        path = probe.probe_verdict_path(self.pkg, "all")
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w", encoding="utf-8") as fh:
+            json.dump({"key": key, "verdict": probe.VERDICT_CRASHED, "detail": "sig 6"}, fh)
+        ok = _Runner(probe.VERDICT_OK)
+        self.ensure(ok)
+        self.assertEqual(len(ok.calls), 1)
+
+
 class _FakeCt:
     """The slice of coremltools `_load_model` touches before the model loads."""