@camstack/addon-pipeline 1.2.335 → 1.2.336

package/dist/{custom-model-catalog-Buehc666.mjs → custom-model-catalog-DSN-2fxO.mjs}

@@ -426,7 +426,7 @@ var yolo26Reduced = (tier, res, sizes) => {
 				sizeMB: sizes.onnx
 			},
 			coreml: {
-				url: hf(`objectDetection/yolo26/coreml/camstack-yolo26${tier}-${res}.mlpackage`),
+				url: hf(`objectDetection/yolo26/coreml/camstack-yolo26${tier}-${res}-static.mlpackage`),
 				sizeMB: sizes.coreml,
 				isDirectory: true,
 				files: [...MLPACKAGE_FILES],

package/dist/{custom-model-catalog-CL-xJa8w.js → custom-model-catalog-jyP-7H7P.js}

@@ -426,7 +426,7 @@ var yolo26Reduced = (tier, res, sizes) => {
 				sizeMB: sizes.onnx
 			},
 			coreml: {
-				url: hf(`objectDetection/yolo26/coreml/camstack-yolo26${tier}-${res}.mlpackage`),
+				url: hf(`objectDetection/yolo26/coreml/camstack-yolo26${tier}-${res}-static.mlpackage`),
 				sizeMB: sizes.coreml,
 				isDirectory: true,
 				files: [...MLPACKAGE_FILES],

package/dist/detection-pipeline/index.js

@@ -5,7 +5,7 @@ Object.defineProperties(exports, {
 const require_chunk = require("../chunk-emK7D4bc.js");
 const require_dist = require("../dist-C5DlS_lW.js");
 const require_node = require("../node-BUafKArW.js");
-const require_custom_model_catalog = require("../custom-model-catalog-CL-xJa8w.js");
+const require_custom_model_catalog = require("../custom-model-catalog-jyP-7H7P.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
 const require_process_memory = require("../process-memory-DWOQCbg5.js");
 let node_os = require("node:os");

package/dist/detection-pipeline/index.mjs

@@ -1,7 +1,7 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
 import { At as loadContributionCapability, Bn as parseJsonUnknown, Bt as overlayClusterStepSettings, Dn as BaseAddon, Fn as hydrateSchema, G as YAMNET_TO_MACRO, Gn as array, Gt as pipelineExecutorCapability, Ht as pickClusterStepSettings, J as applyModelBoundSettings, N as PoolMemoryWatchdog, O as LABEL_SUPPLY_MACRO, Ot as linkedLabelStepId, Qt as resolveClusterStepModelId, Tn as errMsg, Tt as hfModelUrl, Un as sleep, Zn as object, cn as stepModelRunsOnFormat, d as CLUSTER_MODEL_SCOPED_STEPS, er as string, ft as detectionPipelineCapability, g as DEFAULT_CLUSTER_STEP_SETTINGS, gt as evaluateZoneRules, ht as enumerateInferenceDevices, jn as createEvent, n as APPLE_SA_TO_MACRO, nr as EventCategory, on as rootSuppliesOf, pn as supportedRuntimes$1, rn as resolvePoolMemoryPolicy, rt as containingParentIndex, sn as runtimeDevices$1, st as defaultDeviceFor$1, tr as union, zn as nodePin } from "../dist-CPhDwlSN.mjs";
 import { s as readProcessCost } from "../node-DYfEOwjW.mjs";
-import { C as resolveModelDefaultConfidence, S as landmarkPrecisionVerdict, _ as ALL_STEPS, b as getStepDefinition, f as localFrameRegistry, g as ALL_PIPELINE_STEPS, l as resolveDefaultDetectionModel, n as mergeCustomModels, o as deviceKeyOf, r as buildSubtreeCanRun, s as resolveDeviceEngine, t as CustomModelCatalog, u as macroGateVerdict, v as getDefaultModelForFormat, x as resolveModelForFormat, y as getStep } from "../custom-model-catalog-Buehc666.mjs";
+import { C as resolveModelDefaultConfidence, S as landmarkPrecisionVerdict, _ as ALL_STEPS, b as getStepDefinition, f as localFrameRegistry, g as ALL_PIPELINE_STEPS, l as resolveDefaultDetectionModel, n as mergeCustomModels, o as deviceKeyOf, r as buildSubtreeCanRun, s as resolveDeviceEngine, t as CustomModelCatalog, u as macroGateVerdict, v as getDefaultModelForFormat, x as resolveModelForFormat, y as getStep } from "../custom-model-catalog-DSN-2fxO.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
 import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-WPRYnN8c.mjs";
 import * as os from "node:os";

package/dist/pipeline-runner/index.js

@@ -5,7 +5,7 @@ Object.defineProperties(exports, {
 const require_chunk = require("../chunk-emK7D4bc.js");
 const require_dist = require("../dist-C5DlS_lW.js");
 const require_node = require("../node-BUafKArW.js");
-const require_custom_model_catalog = require("../custom-model-catalog-CL-xJa8w.js");
+const require_custom_model_catalog = require("../custom-model-catalog-jyP-7H7P.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
 const require_restream_intent = require("../restream-intent-7uDNqMKs.js");

package/dist/pipeline-runner/index.mjs

@@ -1,6 +1,6 @@
 import { $ as cameraOwnsMotionViaSensor, A as NativeLeaseAdmissionSchema, At as loadContributionCapability, Dn as BaseAddon, Gn as array, Jn as lazy, Kn as boolean, Kt as pipelineRunnerCapability, Mn as customAction, Nn as defineCustomActions, T as FailureCounters, Tn as errMsg, Ut as pickDetailCropConvention, Wn as _enum, Wt as pickNativeLeaseOverride, Xn as number, Yn as literal, Zn as object, _ as DEFAULT_DETAIL_CROP_CONVENTION, a as BackgroundRunRegistry, an as resolveRootSupply, bt as failureContributionCapability, dt as deriveRootFaceRefineRect, er as string, j as NativeLeaseSettingsSchema, jn as createEvent, kt as linkedStepOf, lt as deriveDetailCropRect, m as CROP_SUPPLY_SOURCES, nn as resolveModelBoundSetting, nr as EventCategory, on as rootSuppliesOf, q as allowedSuppliedEffect, y as DEFAULT_NATIVE_LEASE_SETTINGS, z as ROOT_SUPPLIABLE_STEP_IDS, zn as nodePin } from "../dist-CPhDwlSN.mjs";
 import { i as NO_COST_CLAIM, t as ChildCostRegistry } from "../node-DYfEOwjW.mjs";
-import { a as stepsForElectedPool, b as getStepDefinition, d as rootObjectGate, f as localFrameRegistry, h as resolveFrameViewGeometry, i as placeDetailStep, l as resolveDefaultDetectionModel, m as createSessionDecodeCoordinator, p as isSessionDecodeReadGone, s as resolveDeviceEngine, t as CustomModelCatalog, u as macroGateVerdict, y as getStep } from "../custom-model-catalog-Buehc666.mjs";
+import { a as stepsForElectedPool, b as getStepDefinition, d as rootObjectGate, f as localFrameRegistry, h as resolveFrameViewGeometry, i as placeDetailStep, l as resolveDefaultDetectionModel, m as createSessionDecodeCoordinator, p as isSessionDecodeReadGone, s as resolveDeviceEngine, t as CustomModelCatalog, u as macroGateVerdict, y as getStep } from "../custom-model-catalog-DSN-2fxO.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
 import { c as withDetectionIntent, o as preRollRequestOf, t as DETECTION_PRE_ROLL_REQUEST_MS } from "../restream-intent-DyGmLAU9.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-pipeline",
-  "version": "1.2.335",
+  "version": "1.2.336",
   "description": "Pipeline bundle — runner, detection, motion, audio + stream broker. Multi-entry npm package shipping pipeline addons under a single bundle.",
   "keywords": [
     "camstack",

package/python/coreml_load_probe.py

@@ -0,0 +1,223 @@
+"""Load a CoreML package in a CHILD process before the pool loads it in-process.
+
+Why (2026-10-07, M3 Pro, macOS 26.2): the batch-flexible YOLO26 @320/@256
+packages abort ANY process that loads them — SIGABRT from libmalloc inside
+`Espresso::generic_gather_nd_kernel::top_shapes_for_bottom_shapes`, on every
+compute unit, with coremltools 8.3 and 9.0 alike. Python cannot catch an
+abort, so the pool worker died, the host respawned it, and the respawned
+worker went straight back into the same load.
+
+So the first load of a package (per fingerprint, compute unit and OS build)
+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
+  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. A Python-level failure raises the same
+exception in-process, which the pool already turns into an error reply.
+
+The child runs the pool's own `_acquire_coreml_model`, so on success it has
+also written the compiled-model cache and the in-process load is a cache HIT:
+the probe costs one interpreter start and one cached load, once per package.
+"""
+from __future__ import annotations
+
+import json
+import os
+import platform
+import signal
+import subprocess
+import sys
+from typing import Callable, Optional
+
+# One-way: inference_pool imports this module lazily, inside its CoreML branch.
+from inference_pool import COREML_CACHE_DIR_NAME, _coreml_model_fingerprint
+
+VERDICT_OK = "ok"
+VERDICT_CRASHED = "crashed"
+VERDICT_INCONCLUSIVE = "inconclusive"
+
+PROBE_VERDICT_VERSION = 1
+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.
+PROBE_TIMEOUT_SEC = 600.0
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+
+# The child loads the package exactly as the pool does (same function, same
+# compute units, same compiled-model cache) and runs one predict on a neutral
+# input, then prints the marker. It never touches the parent's state.
+_CHILD_CODE = f"""
+import json, sys
+args = json.loads(sys.argv[1])
+sys.path.insert(0, args["pool_dir"])
+import coremltools as ct
+import numpy as np
+from PIL import Image
+import inference_pool as ip
+units = {{"cpu": ct.ComputeUnit.CPU_ONLY, "gpu": ct.ComputeUnit.CPU_AND_GPU,
+         "ane": ct.ComputeUnit.CPU_AND_NE, "all": ct.ComputeUnit.ALL}}
+model, spec = ip._acquire_coreml_model(ct, args["path"], units.get(args["device"], ct.ComputeUnit.ALL))
+feed = {{}}
+for inp in spec.description.input:
+    kind = inp.type.WhichOneof("Type")
+    if kind == "imageType":
+        feed[inp.name] = Image.new("RGB", (inp.type.imageType.width, inp.type.imageType.height), (114, 114, 114))
+    elif kind == "multiArrayType":
+        mat = inp.type.multiArrayType
+        if mat.WhichOneof("ShapeFlexibility") == "shapeRange":
+            shape = [max(1, r.lowerBound) for r in mat.shapeRange.sizeRanges]
+        else:
+            shape = [max(1, d) for d in mat.shape]
+        feed[inp.name] = np.zeros(shape, dtype=np.float32)
+if feed:
+    model.predict(feed)
+print({PROBE_MARKER!r}, flush=True)
+"""
+
+ProbeRunner = Callable[[str, str], "tuple[str, str]"]
+
+
+class CoremlLoadCrashed(Exception):
+    """The package kills the native loader; it is refused instead of loaded."""
+
+    reason = "native-load-crashed"
+
+    def __init__(self, model_path: str, device: str, detail: str) -> None:
+        self.model_path = model_path
+        self.device = device
+        self.detail = detail
+        super().__init__(
+            f"CoreML package {os.path.basename(model_path)} crashes the native loader "
+            f"on device={device} ({detail}); refused so it cannot take the pool down. "
+            f"Run this model through ONNX Runtime, or replace the package"
+        )
+
+
+def classify_probe_exit(returncode: int, marker_seen: bool) -> str:
+    """Pure: the probe child's exit -> verdict. Only a signal death is a crash."""
+    if returncode < 0:
+        return VERDICT_CRASHED
+    if returncode == 0 and marker_seen:
+        return VERDICT_OK
+    return VERDICT_INCONCLUSIVE
+
+
+def _signal_name(signum: int) -> str:
+    try:
+        return signal.Signals(signum).name
+    except ValueError:
+        return str(signum)
+
+
+def run_probe(
+    model_path: str,
+    device: str,
+    child_code: str = _CHILD_CODE,
+    timeout_sec: float = PROBE_TIMEOUT_SEC,
+) -> "tuple[str, str]":
+    """Load `model_path` in a fresh interpreter; return (verdict, detail)."""
+    payload = json.dumps({"path": model_path, "device": device, "pool_dir": _HERE})
+    try:
+        proc = subprocess.run(
+            [sys.executable, "-c", child_code, payload],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True,
+            timeout=timeout_sec,
+        )
+    except subprocess.TimeoutExpired:
+        return VERDICT_INCONCLUSIVE, f"probe timed out after {timeout_sec:g}s"
+    except OSError as exc:
+        return VERDICT_INCONCLUSIVE, f"probe could not start ({exc})"
+    marker_seen = any(line.strip() == PROBE_MARKER for line in proc.stdout.splitlines())
+    verdict = classify_probe_exit(proc.returncode, marker_seen)
+    tail = " | ".join(proc.stderr.strip().splitlines()[-3:])
+    if proc.returncode < 0:
+        detail = f"probe child died by signal {-proc.returncode} ({_signal_name(-proc.returncode)})"
+    else:
+        detail = f"probe child exited {proc.returncode}"
+    return verdict, f"{detail}{': ' + tail if tail else ''}"
+
+
+# The runner `ensure_coreml_loadable` uses when it is given none — looked up
+# at call time, so a test can replace it.
+DEFAULT_RUNNER: ProbeRunner = run_probe
+
+
+def current_os_build() -> str:
+    """The OS the verdict was measured on: a macOS update may fix or break a package."""
+    release = platform.mac_ver()[0]
+    return f"{release or platform.system()} {platform.version()}"
+
+
+def probe_verdict_path(model_path: str, device: str) -> str:
+    models_dir = os.path.dirname(os.path.abspath(model_path))
+    stem = os.path.splitext(os.path.basename(model_path))[0]
+    return os.path.join(models_dir, COREML_CACHE_DIR_NAME, f"{stem}.{device}.probe.json")
+
+
+def _read_verdict(path: str, key: dict) -> Optional[dict]:
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            stored = json.load(fh)
+    except (OSError, ValueError):
+        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
+
+
+def _write_verdict(path: str, key: dict, verdict: str, detail: str) -> None:
+    """Atomic replace; a verdict that cannot be written only costs a re-probe."""
+    tmp = f"{path}.tmp-{os.getpid()}"
+    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)
+        os.replace(tmp, path)
+    except OSError as exc:
+        sys.stderr.write(f"CoreML probe: could not persist the verdict for {path} ({exc})\n")
+        sys.stderr.flush()
+        try:
+            os.remove(tmp)
+        except OSError:
+            pass
+
+
+def ensure_coreml_loadable(
+    model_path: str,
+    device: str,
+    run: Optional[ProbeRunner] = None,
+    os_build: Optional[str] = None,
+) -> None:
+    """Return when `model_path` may be loaded in-process; raise when it would crash."""
+    key = {
+        "version": PROBE_VERDICT_VERSION,
+        "fingerprint": _coreml_model_fingerprint(model_path),  # a re-download is a new package
+        "device": device,
+        "os": os_build if os_build is not None else current_os_build(),
+    }
+    verdict_path = probe_verdict_path(model_path, device)
+    known = _read_verdict(verdict_path, key)
+    name = os.path.basename(model_path)
+    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()
+            raise CoremlLoadCrashed(model_path, device, str(known.get("detail") or "known crash"))
+        return
+    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):
+        _write_verdict(verdict_path, key, verdict, detail)
+    if verdict == VERDICT_CRASHED:
+        raise CoremlLoadCrashed(model_path, device, detail)

package/python/inference_pool.py

@@ -614,6 +614,13 @@ def _coreml_model_fingerprint(model_path: str) -> dict:
     Works for both a plain file (.mlmodel) and a .mlpackage DIRECTORY (the
     normal case), whose top-level mtime alone would not reflect content edits.
     JSON-serializable so it round-trips through the stamp file unchanged.
+
+    The package's top-level `Manifest.json` counts by size only, never by
+    mtime: coremltools rewrites it (same bytes) on EVERY open of the package —
+    `MLModel` and `utils.load_spec` alike (measured, coremltools 8.3, macOS
+    26.2). The cache HIT path calls `load_spec`, so keyed on that mtime every
+    HIT invalidated the stamp for the next spawn: HIT, MISS, HIT, MISS. A
+    re-download rewrites the model and weights files too, so it still shows.
     """
     if not os.path.isdir(model_path):
         st = os.stat(model_path)
@@ -621,13 +628,17 @@ def _coreml_model_fingerprint(model_path: str) -> dict:
     total_size = 0
     latest_mtime = 0
     file_count = 0
+    manifest = os.path.join(model_path, "Manifest.json")
     for root, _dirs, files in os.walk(model_path):
         for name in files:
-            st = os.stat(os.path.join(root, name))
+            file_path = os.path.join(root, name)
+            st = os.stat(file_path)
             total_size += st.st_size
+            file_count += 1
+            if file_path == manifest:
+                continue
             if st.st_mtime_ns > latest_mtime:
                 latest_mtime = st.st_mtime_ns
-            file_count += 1
     return {"kind": "dir", "files": file_count, "size": total_size, "mtimeNs": latest_mtime}
 
 
@@ -1032,6 +1043,14 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
         # compile + persist on miss) and returns the spec read via
         # ct.utils.load_spec on hits — falling back to the plain
         # MLModel/get_spec() path on ANY cache failure.
+        #
+        # First, the package is loaded once in a CHILD process: a package that
+        # aborts Core ML's native loader (SIGABRT, which Python cannot catch)
+        # is refused here with `CoremlLoadCrashed` instead of killing this
+        # worker and, through the respawn, every worker after it.
+        import coreml_load_probe
+
+        coreml_load_probe.ensure_coreml_loadable(path, device)
         model, spec = _acquire_coreml_model(
             ct, path, compute_map.get(device, ct.ComputeUnit.ALL),
         )
@@ -2870,7 +2889,14 @@ async def _handle_model_command(
             "error": str(exc),
         }
     except Exception as exc:
-        return {"cmd": action, "index": index, "status": "error", "error": str(exc)}
+        reply = {"cmd": action, "index": index, "status": "error", "error": str(exc)}
+        # A typed refusal (e.g. `native-load-crashed`) names its class, so the
+        # host can tell it from an ordinary failed load.
+        reason = getattr(exc, "reason", None)
+        if isinstance(reason, str):
+            reply["reason"] = reason
+            reply["modelId"] = model_id
+        return reply
     models[index] = slot
     load_ms = round((time.perf_counter() - t0) * 1000)
     verb = "loaded" if action == "load" else "replaced"

package/python/test_coreml_load_probe.py

@@ -0,0 +1,295 @@
+"""Unit tests for the CoreML child-process load probe (coreml_load_probe).
+
+A CoreML package that aborts the native loader (SIGABRT inside Core ML) takes
+the whole pool process with it, and the host respawns the pool straight into
+the same load. The probe loads the package in a CHILD first, remembers the
+verdict per (package fingerprint, compute unit, OS build), and refuses a
+package whose child died by a signal — with an exception, not a crash.
+
+Covers:
+  - classify_probe_exit — the exit -> verdict mapping (signal = crashed only).
+  - run_probe — a REAL child that calls os.abort() is classified `crashed`,
+    a child that prints the marker is `ok`.
+  - ensure_coreml_loadable — verdict persistence: a crash refuses now and on
+    the next call without re-probing; `ok` is not re-probed; a changed package
+    is re-probed; an inconclusive probe is not remembered and does not refuse.
+  - inference_pool._load_model (coreml branch) — a package the probe calls
+    crashed never reaches `ct.models.MLModel`.
+
+Pure-python: stubs numpy / PIL / postprocessors when absent, like the other
+inference_pool tests.
+
+Run: python3 -m unittest test_coreml_load_probe -v
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import tempfile
+import types
+import unittest
+
+try:
+    import numpy  # noqa: F401
+except ImportError:
+    _np = types.ModuleType("numpy")
+    _np.array = lambda seq, dtype=None: list(seq)  # noqa: E731
+    _np.float32 = "float32"
+    sys.modules["numpy"] = _np
+
+try:
+    import PIL.Image  # noqa: F401
+except ImportError:
+    _pil = types.ModuleType("PIL")
+    _pil_image = types.ModuleType("PIL.Image")
+    _pil.Image = _pil_image
+    sys.modules["PIL"] = _pil
+    sys.modules["PIL.Image"] = _pil_image
+
+if "postprocessors" not in sys.modules:
+    _pp = types.ModuleType("postprocessors")
+    _pp.POSTPROCESSORS = {}
+    sys.modules["postprocessors"] = _pp
+
+import coreml_load_probe as probe
+import inference_pool as ip
+
+
+def _write(path: str, content: bytes = b"x") -> None:
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "wb") as fh:
+        fh.write(content)
+
+
+def _make_mlpackage(root: str, name: str = "camstack-yolo26n-320.mlpackage") -> str:
+    pkg = os.path.join(root, name)
+    _write(os.path.join(pkg, "Manifest.json"), b"{}")
+    _write(os.path.join(pkg, "Data", "com.apple.CoreML", "model.mlmodel"), b"graph")
+    return pkg
+
+
+class _Runner:
+    """A fake probe runner: answers a fixed verdict and counts its calls."""
+
+    def __init__(self, verdict: str, detail: str = "") -> None:
+        self.verdict = verdict
+        self.detail = detail
+        self.calls: list[tuple[str, str]] = []
+
+    def __call__(self, model_path: str, device: str) -> "tuple[str, str]":
+        self.calls.append((model_path, device))
+        return self.verdict, self.detail
+
+
+class ClassifyProbeExitTest(unittest.TestCase):
+    def test_marker_and_zero_exit_is_ok(self) -> None:
+        self.assertEqual(probe.classify_probe_exit(0, True), probe.VERDICT_OK)
+
+    def test_death_by_signal_is_crashed(self) -> None:
+        # subprocess reports a signal death as -signum (SIGABRT = 6).
+        self.assertEqual(probe.classify_probe_exit(-6, False), probe.VERDICT_CRASHED)
+        self.assertEqual(probe.classify_probe_exit(-11, False), probe.VERDICT_CRASHED)
+
+    def test_python_exception_is_inconclusive(self) -> None:
+        # A Python-level failure raises the same exception in-process: harmless,
+        # so it is not a reason to refuse the package.
+        self.assertEqual(probe.classify_probe_exit(1, False), probe.VERDICT_INCONCLUSIVE)
+
+    def test_clean_exit_without_marker_is_inconclusive(self) -> None:
+        self.assertEqual(probe.classify_probe_exit(0, False), probe.VERDICT_INCONCLUSIVE)
+
+
+class RunProbeRealChildTest(unittest.TestCase):
+    """The child is a real interpreter: a native abort is seen as a crash."""
+
+    def test_child_that_aborts_is_crashed(self) -> None:
+        verdict, detail = probe.run_probe(
+            "/nonexistent.mlpackage", "all", child_code="import os; os.abort()",
+        )
+        self.assertEqual(verdict, probe.VERDICT_CRASHED)
+        self.assertIn("signal", detail)
+
+    def test_child_that_prints_marker_is_ok(self) -> None:
+        code = f"print({probe.PROBE_MARKER!r}, flush=True)"
+        verdict, _ = probe.run_probe("/nonexistent.mlpackage", "all", child_code=code)
+        self.assertEqual(verdict, probe.VERDICT_OK)
+
+    def test_child_that_raises_is_inconclusive(self) -> None:
+        verdict, _ = probe.run_probe(
+            "/nonexistent.mlpackage", "all", child_code="raise RuntimeError('bad spec')",
+        )
+        self.assertEqual(verdict, probe.VERDICT_INCONCLUSIVE)
+
+    def test_child_past_its_bound_is_inconclusive(self) -> None:
+        verdict, detail = probe.run_probe(
+            "/nonexistent.mlpackage", "all", child_code="import time; time.sleep(30)",
+            timeout_sec=0.5,
+        )
+        self.assertEqual(verdict, probe.VERDICT_INCONCLUSIVE)
+        self.assertIn("timed out", detail)
+
+
+class EnsureCoremlLoadableTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self._tmp = tempfile.TemporaryDirectory()
+        self.pkg = _make_mlpackage(self._tmp.name)
+
+    def tearDown(self) -> None:
+        self._tmp.cleanup()
+
+    def test_crash_refuses_with_a_typed_reason(self) -> None:
+        runner = _Runner(probe.VERDICT_CRASHED, "child died by signal 6 (SIGABRT)")
+        with self.assertRaises(probe.CoremlLoadCrashed) as ctx:
+            probe.ensure_coreml_loadable(self.pkg, "all", run=runner)
+        self.assertEqual(ctx.exception.reason, "native-load-crashed")
+        self.assertIn("camstack-yolo26n-320", str(ctx.exception))
+
+    def test_crash_is_remembered_and_not_reprobed(self) -> None:
+        runner = _Runner(probe.VERDICT_CRASHED)
+        with self.assertRaises(probe.CoremlLoadCrashed):
+            probe.ensure_coreml_loadable(self.pkg, "all", run=runner)
+        with self.assertRaises(probe.CoremlLoadCrashed):
+            probe.ensure_coreml_loadable(self.pkg, "all", run=runner)
+        self.assertEqual(len(runner.calls), 1)
+
+    def test_ok_is_remembered_and_not_reprobed(self) -> None:
+        runner = _Runner(probe.VERDICT_OK)
+        probe.ensure_coreml_loadable(self.pkg, "all", run=runner)
+        probe.ensure_coreml_loadable(self.pkg, "all", run=runner)
+        self.assertEqual(len(runner.calls), 1)
+
+    def test_a_load_that_rewrites_the_package_is_not_reprobed(self) -> None:
+        # Core ML rewrites a file inside the .mlpackage when it loads it (seen
+        # on macOS 26.2: the package's max mtime moves on every MLModel load),
+        # so the verdict must be keyed on the package as the probe LEFT it.
+        manifest = os.path.join(self.pkg, "Manifest.json")
+
+        def touching_runner(model_path: str, device: str) -> "tuple[str, str]":
+            touching_runner.calls += 1  # type: ignore[attr-defined]
+            st = os.stat(manifest)
+            os.utime(manifest, ns=(st.st_atime_ns, st.st_mtime_ns + 1_000_000_000))
+            return probe.VERDICT_CRASHED, "child died by signal 6"
+
+        touching_runner.calls = 0  # type: ignore[attr-defined]
+        for _ in range(2):
+            with self.assertRaises(probe.CoremlLoadCrashed):
+                probe.ensure_coreml_loadable(self.pkg, "all", run=touching_runner)
+        self.assertEqual(touching_runner.calls, 1)  # type: ignore[attr-defined]
+
+    def test_verdict_is_per_compute_unit(self) -> None:
+        runner = _Runner(probe.VERDICT_OK)
+        probe.ensure_coreml_loadable(self.pkg, "all", run=runner)
+        probe.ensure_coreml_loadable(self.pkg, "cpu", run=runner)
+        self.assertEqual([d for _, d in runner.calls], ["all", "cpu"])
+
+    def test_a_changed_package_is_reprobed(self) -> None:
+        crashed = _Runner(probe.VERDICT_CRASHED)
+        with self.assertRaises(probe.CoremlLoadCrashed):
+            probe.ensure_coreml_loadable(self.pkg, "all", run=crashed)
+        # A re-download replaces the package: different size -> different fingerprint.
+        _write(os.path.join(self.pkg, "Data", "com.apple.CoreML", "model.mlmodel"), b"fixed graph")
+        ok = _Runner(probe.VERDICT_OK)
+        probe.ensure_coreml_loadable(self.pkg, "all", run=ok)
+        self.assertEqual(len(ok.calls), 1)
+
+    def test_a_different_os_build_is_reprobed(self) -> None:
+        runner = _Runner(probe.VERDICT_CRASHED)
+        with self.assertRaises(probe.CoremlLoadCrashed):
+            probe.ensure_coreml_loadable(self.pkg, "all", run=runner, os_build="26.2")
+        ok = _Runner(probe.VERDICT_OK)
+        probe.ensure_coreml_loadable(self.pkg, "all", run=ok, os_build="26.3")
+        self.assertEqual(len(ok.calls), 1)
+
+    def test_inconclusive_neither_refuses_nor_is_remembered(self) -> None:
+        runner = _Runner(probe.VERDICT_INCONCLUSIVE, "child exited 1")
+        probe.ensure_coreml_loadable(self.pkg, "all", run=runner)
+        probe.ensure_coreml_loadable(self.pkg, "all", run=runner)
+        self.assertEqual(len(runner.calls), 2)
+
+    def test_verdict_lives_in_the_coreml_cache_dir(self) -> None:
+        probe.ensure_coreml_loadable(self.pkg, "ane", run=_Runner(probe.VERDICT_OK))
+        verdict_path = probe.probe_verdict_path(self.pkg, "ane")
+        self.assertEqual(
+            os.path.dirname(verdict_path),
+            os.path.join(self._tmp.name, ip.COREML_CACHE_DIR_NAME),
+        )
+        with open(verdict_path, "r", encoding="utf-8") as fh:
+            self.assertEqual(json.load(fh)["verdict"], probe.VERDICT_OK)
+
+    def test_an_unreadable_verdict_file_is_reprobed(self) -> None:
+        _write(probe.probe_verdict_path(self.pkg, "all"), b"{not json")
+        runner = _Runner(probe.VERDICT_OK)
+        probe.ensure_coreml_loadable(self.pkg, "all", run=runner)
+        self.assertEqual(len(runner.calls), 1)
+
+
+class _FakeCt:
+    """The slice of coremltools `_load_model` touches before the model loads."""
+
+    class ComputeUnit:
+        CPU_ONLY = "CPU_ONLY"
+        CPU_AND_GPU = "CPU_AND_GPU"
+        CPU_AND_NE = "CPU_AND_NE"
+        ALL = "ALL"
+
+    def __init__(self) -> None:
+        self.mlmodel_calls = 0
+        outer = self
+
+        class _Models:
+            @staticmethod
+            def MLModel(*_a, **_k):  # noqa: N802 — coremltools' name
+                outer.mlmodel_calls += 1
+                raise AssertionError("the native loader must not be reached")
+
+            @staticmethod
+            def CompiledMLModel(*_a, **_k):  # noqa: N802
+                outer.mlmodel_calls += 1
+                raise AssertionError("the native loader must not be reached")
+
+        self.models = _Models
+        self.utils = types.SimpleNamespace(load_spec=lambda _p: None)
+
+
+class LoadModelGateTest(unittest.TestCase):
+    """`_load_model` asks the probe BEFORE the in-process native load."""
+
+    def test_crashed_package_never_reaches_the_native_loader(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            pkg = _make_mlpackage(tmp)
+            fake_ct = _FakeCt()
+            saved = (ip._runtime, ip._runtime_lib, probe.DEFAULT_RUNNER)
+            try:
+                ip._runtime = "coreml"
+                ip._runtime_lib = fake_ct
+                probe.DEFAULT_RUNNER = _Runner(probe.VERDICT_CRASHED, "child died by signal 6")
+                with self.assertRaises(probe.CoremlLoadCrashed):
+                    ip._load_model(ip.ModelSlot(), {"path": pkg, "device": "all"})
+            finally:
+                (ip._runtime, ip._runtime_lib, probe.DEFAULT_RUNNER) = saved
+            self.assertEqual(fake_ct.mlmodel_calls, 0)
+
+
+class ModelCommandReasonTest(unittest.TestCase):
+    """A refused load answers the host with the machine-readable reason."""
+
+    def test_load_reply_carries_native_load_crashed(self) -> None:
+        import asyncio
+
+        def failing_load(_slot, config):
+            raise probe.CoremlLoadCrashed(config["path"], "all", "child died by signal 6")
+
+        async def run() -> dict:
+            loader = ip.ModelLoader(timeout_sec=5.0, load_fn=failing_load)
+            cmd = {"cmd": "load", "index": 0, "config": {"path": "/m/camstack-yolo26n-320.mlpackage"}}
+            return await ip._handle_model_command([], cmd, loader)
+
+        reply = asyncio.run(run())
+        self.assertEqual(reply["status"], "error")
+        self.assertEqual(reply["reason"], "native-load-crashed")
+        self.assertEqual(reply["modelId"], "camstack-yolo26n-320")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/test_inference_pool_coreml_cache.py

@@ -124,6 +124,13 @@ class CoremlModelFingerprintTest(unittest.TestCase):
             after = _coreml_model_fingerprint(pkg)
             self.assertNotEqual(before, after)
 
+    def test_manifest_rewrite_with_same_bytes_keeps_fingerprint(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            pkg = _make_mlpackage(tmp)
+            before = _coreml_model_fingerprint(pkg)
+            _touch_manifest(pkg)
+            self.assertEqual(_coreml_model_fingerprint(pkg), before)
+
     def test_fingerprint_survives_json_round_trip(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             pkg = _make_mlpackage(tmp)
@@ -241,10 +248,22 @@ class _FakeCompiledMLModel:
         self.compute_units = compute_units
 
 
+def _touch_manifest(pkg: str) -> None:
+    """What coremltools does on EVERY open of an .mlpackage (MLModel AND
+    utils.load_spec, measured with coremltools 8.3 on macOS 26.2): it rewrites
+    Manifest.json with the same bytes, so only its mtime moves."""
+    manifest = os.path.join(pkg, "Manifest.json")
+    st = os.stat(manifest)
+    os.utime(manifest, ns=(st.st_atime_ns, st.st_mtime_ns + 1_000_000_000))
+
+
 class _FakeCt:
     """Minimal stand-in for the coremltools module surface the helper uses."""
 
-    def __init__(self, tmp: str, fail_compiled: bool = False, fail_load_spec: bool = False) -> None:
+    def __init__(
+        self, tmp: str, fail_compiled: bool = False, fail_load_spec: bool = False,
+        touch_manifest: bool = False,
+    ) -> None:
         self.tmp = tmp
         self.mlmodel_calls: list[tuple[str, object]] = []
         self.compiled_calls: list[tuple[str, object]] = []
@@ -256,6 +275,8 @@ class _FakeCt:
         class _MLModel:
             def __new__(cls, path: str, compute_units: object = None) -> _FakeMLModel:
                 fake.mlmodel_calls.append((path, compute_units))
+                if touch_manifest:
+                    _touch_manifest(path)
                 compiled = os.path.join(fake.tmp, f"compiled-{len(fake.mlmodel_calls)}.mlmodelc")
                 _write(os.path.join(compiled, "coremldata.bin"), b"compiled")
                 return _FakeMLModel(compiled)
@@ -269,6 +290,8 @@ class _FakeCt:
 
         def _load_spec(path: str) -> _FakeSpec:
             fake.load_spec_calls.append(path)
+            if touch_manifest:
+                _touch_manifest(path)
             if fail_load_spec:
                 raise RuntimeError("load_spec failed")
             return fake.loaded_spec
@@ -311,6 +334,19 @@ class AcquireCoremlModelTest(unittest.TestCase):
             self.assertEqual(ct.load_spec_calls, [pkg])
             self.assertEqual(ct.mlmodel_calls, [])
 
+    def test_a_hit_does_not_invalidate_the_next_hit(self) -> None:
+        # The HIT path reads the spec with `ct.utils.load_spec`, which rewrites
+        # the package's Manifest.json. Keyed on that mtime, every HIT
+        # invalidated the cache for the NEXT spawn: HIT, MISS, HIT, MISS.
+        with tempfile.TemporaryDirectory() as tmp:
+            pkg = _make_mlpackage(tmp)
+            _acquire_coreml_model(_FakeCt(tmp, touch_manifest=True), pkg, self.CU)  # MISS
+            for _ in range(3):
+                ct = _FakeCt(tmp, touch_manifest=True)
+                model, _ = _acquire_coreml_model(ct, pkg, self.CU)
+                self.assertIsInstance(model, _FakeCompiledMLModel)
+                self.assertEqual(ct.mlmodel_calls, [])
+
     def test_changed_model_invalidates_cache_and_recompiles(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             pkg = _make_mlpackage(tmp)