@camstack/addon-pipeline 1.2.333 → 1.2.335

package/dist/stream-broker/index.js

@@ -3,12 +3,12 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-DJV7Z6Bb.js");
-const require_node = require("../node-CkmucLYG.js");
+const require_dist = require("../dist-C5DlS_lW.js");
+const require_node = require("../node-BUafKArW.js");
 const require_restream_intent = require("../restream-intent-7uDNqMKs.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
 const require_retire_root_keys = require("../retire-root-keys-Csb8z2f3.js");
-const require_segment_demux_js = require("../segment-demux-js-mK9IBGLf.js");
+const require_segment_demux_js = require("../segment-demux-js-DWIgUPW1.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_crypto = require("node:crypto");

package/dist/stream-broker/index.mjs

@@ -1,10 +1,10 @@
 import { r as __toESM } from "../chunk-DnnnRqeS.mjs";
-import { $ as cameraStreamsCapability, $n as union, $t as resolveEgressDecodeHwAccel, At as logChannelsCapability, C as EncodeProfileSchema, Cn as errMsg, Ct as gifFromMp4Args, Dn as CamProfileSchema, E as G711_SCALE_CORRECTION_DB, En as CAM_PROFILE_ORDER, F as RATE_CONTROL_TIGHT, Fn as makeProfileBrokerId, Ft as memoizePinnedFfmpeg, Gn as discriminatedUnion, H as RingBuffer, Hn as _enum, In as makeSourceBrokerId, Jn as number, K as addonWidgetsSourceCapability, Kt as rankStreams, Ln as nodePin, Mn as expandAudioChunkToF32le, Mt as maskUrlCredentials, P as RATE_CONTROL_RELAXED, Pn as isEvent, Qn as string, Sn as DeviceType, St as gifDeriveSpeed, Tn as BaseAddon, Un as array, Wn as boolean, Yn as object, Z as batteryCapability, Zn as record, _n as buildFfmpegArgs$1, at as declareLogChannel, bn as isSoftwareDecode, bt as ffmpegRate, c as CLIP_STILL_REASON_CODE_HEADER, er as EventCategory, ft as egressTranscodeSharingKey, it as createLogChannelsProvider, kn as createEvent, kt as loadContributionCapability, ln as streamBrokerCapability, mn as AUDIO_PRESETS, o as BatteryStatusSchema, pn as webrtcSessionCapability, pt as egressTransportFromRequest, qn as literal, rt as createHwAccelCache, s as CLIP_BROKER_PACED_RATES, st as deriveBatteryPresence, tt as clipExportFailureOf, wn as BOOT_RECOVERY_BACKOFF_MS, xn as DeviceFeature, yn as invocationFromEncodeProfile, zn as parseProfileBrokerId } from "../dist-BsT15i7i.mjs";
-import { i as NO_COST_CLAIM, n as Fmp4FragmentChild, o as probeFfmpegBinary, r as Fmp4FragmentPlane, t as ChildCostRegistry } from "../node-Crsi_8ea.mjs";
+import { $n as record, At as loadContributionCapability, C as EncodeProfileSchema, Cn as DeviceFeature, Ct as gifDeriveSpeed, Dn as BaseAddon, E as G711_SCALE_CORRECTION_DB, En as BOOT_RECOVERY_BACKOFF_MS, F as RATE_CONTROL_TIGHT, Gn as array, H as RingBuffer, In as isEvent, It as memoizePinnedFfmpeg, K as addonWidgetsSourceCapability, Kn as boolean, Ln as makeProfileBrokerId, Nt as maskUrlCredentials, On as CAM_PROFILE_ORDER, P as RATE_CONTROL_RELAXED, Pn as expandAudioChunkToF32le, Q as batteryCapability, Rn as makeSourceBrokerId, Sn as isSoftwareDecode, Tn as errMsg, Vn as parseProfileBrokerId, Wn as _enum, Xn as number, Yn as literal, Zn as object, at as createLogChannelsProvider, c as CLIP_STILL_REASON_CODE_HEADER, ct as deriveBatteryPresence, dn as streamBrokerCapability, en as resolveEgressDecodeHwAccel, er as string, et as cameraStreamsCapability, gn as AUDIO_PRESETS, hn as webrtcSessionCapability, it as createHwAccelCache, jn as createEvent, jt as logChannelsCapability, kn as CamProfileSchema, mt as egressTransportFromRequest, nr as EventCategory, nt as clipExportFailureOf, o as BatteryStatusSchema, ot as declareLogChannel, pt as egressTranscodeSharingKey, qn as discriminatedUnion, qt as rankStreams, s as CLIP_BROKER_PACED_RATES, tr as union, wn as DeviceType, wt as gifFromMp4Args, xn as invocationFromEncodeProfile, xt as ffmpegRate, yn as buildFfmpegArgs$1, zn as nodePin } from "../dist-CPhDwlSN.mjs";
+import { i as NO_COST_CLAIM, n as Fmp4FragmentChild, o as probeFfmpegBinary, r as Fmp4FragmentPlane, t as ChildCostRegistry } from "../node-DYfEOwjW.mjs";
 import { a as parseRestreamPath, d as PREBUFFER_MAX_MS, f as capPreRollRequestMs, i as isLiveEdgeOnlyDial, m as resolvePrebuffer, n as NO_DECLARATION, p as prebufferRetentionMs, s as sdpVariantFor, u as withSentryIntent } from "../restream-intent-DyGmLAU9.mjs";
 import { n as profileForStreamId } from "../remote-restream-BeHi78PZ.mjs";
 import { n as RowMapStore, t as retireRootKeys } from "../retire-root-keys-DZvlso2l.mjs";
-import { a as require_mp4box_all, c as parseNalLengthSize, i as runFfmpegOnce, n as demuxSegmentPreferJs, o as avccSampleToAnnexB, r as FfmpegFallbackRefusedError, s as buildKeyframeAnnexB, t as demuxSegmentFullJs } from "../segment-demux-js-B_tboBcJ.mjs";
+import { a as require_mp4box_all, c as parseNalLengthSize, i as runFfmpegOnce, n as demuxSegmentPreferJs, o as avccSampleToAnnexB, r as FfmpegFallbackRefusedError, s as buildKeyframeAnnexB, t as demuxSegmentFullJs } from "../segment-demux-js-Kz4EnmOr.mjs";
 import { createRequire } from "node:module";
 import * as os from "node:os";
 import { networkInterfaces, tmpdir } from "node:os";

package/dist/stream-broker/remoteEntry.js

@@ -30,7 +30,7 @@ async function d(e) {
 	}
 }
 async function f() {
-	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-a3HMFtd5.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-RPk9F8CY.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

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

package/python/inference_pool.py

@@ -389,6 +389,34 @@ def _ov_compilation_properties(supported: Any, threads: int) -> dict:
     return {"COMPILATION_NUM_THREADS": threads}
 
 
+# Inference precisions a catalog entry may require on an OpenVINO GPU.
+_OV_GPU_PRECISIONS = ("f32", "f16")
+
+
+def _ov_precision_properties(config: dict, device: str, supported: Any) -> dict:
+    """The INFERENCE_PRECISION_HINT a model's catalog entry requires on a GPU.
+
+    An Intel GPU runs an FP32 IR at f16 by default. Some IRs do not survive
+    that: on 2026-10-07 the YOLO26 base IRs `yolo26s`, `yolo26m` and
+    `yolo26m-320` returned no valid detection on the Core Ultra iGPU and the
+    N100 (0 true / 146 false positives, or NaN scores) and matched the CPU at
+    f32. The entry says so (`gpuInferencePrecision`, threaded as config key
+    `gpuInferencePrecision`) — never a model-name match.
+
+    GPU only: the NPU and CPU already compute these IRs correctly. And only for
+    a device that lists the key — a rejected property would make the failover
+    loop push the model onto the next device.
+    """
+    precision = config.get("gpuInferencePrecision")
+    if precision not in _OV_GPU_PRECISIONS:
+        return {}
+    if not str(device).upper().startswith("GPU"):
+        return {}
+    if "INFERENCE_PRECISION_HINT" not in set(supported):
+        return {}
+    return {"INFERENCE_PRECISION_HINT": precision}
+
+
 def _resolve_ov_devices(available: list[str], full_names: dict[str, str]) -> list[str]:
     """Ordered EXPLICIT device candidates for compile-time failover (NPU>GPU>CPU).
 
@@ -1127,6 +1155,7 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
         # `nproc` threads for the life of the process and the operator must be
         # able to SEE that rather than assume the bound applied.
         ov_compile_threads = 0
+        ov_precision = "device-default"
         last_exc: Optional[BaseException] = None
         for candidate in candidates:
             try:
@@ -1143,12 +1172,16 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
                 # OV_COMPILATION_NUM_THREADS). Gated on the device's own
                 # SUPPORTED_PROPERTIES so a plugin that does not know the key
                 # compiles unchanged instead of failing over to the CPU.
+                candidate_supported = _ov_supported_properties(core, candidate)
                 candidate_config = {
                     **ov_config,
                     **_ov_compilation_properties(
-                        _ov_supported_properties(core, candidate),
+                        candidate_supported,
                         OV_COMPILATION_NUM_THREADS,
                     ),
+                    # A model the GPU must not run at its default f16
+                    # (catalog `gpuInferencePrecision`).
+                    **_ov_precision_properties(config, candidate, candidate_supported),
                 }
                 compiled = core.compile_model(
                     candidate_source, device_name=candidate, config=candidate_config,
@@ -1157,6 +1190,9 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
                 ov_compile_threads = int(
                     candidate_config.get("COMPILATION_NUM_THREADS", 0)
                 )
+                ov_precision = str(
+                    candidate_config.get("INFERENCE_PRECISION_HINT", "device-default")
+                )
                 break
             except Exception as exc:
                 last_exc = exc
@@ -1178,8 +1214,22 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
         sys.stderr.write(
             f"OpenVINO: compiled {os.path.basename(path)} mode={ov_device} "
             f"EXECUTION_DEVICES={_exec_devices} compilationThreads="
-            f"{ov_compile_threads if ov_compile_threads > 0 else 'unbounded(device rejects the key)'}\n"
+            f"{ov_compile_threads if ov_compile_threads > 0 else 'unbounded(device rejects the key)'}"
+            f" inferencePrecision={ov_precision}\n"
         )
+        # A model that needs a GPU precision the device would not take runs at
+        # f16 and may return garbage — say so rather than look healthy.
+        if (
+            config.get("gpuInferencePrecision") in _OV_GPU_PRECISIONS
+            and str(ov_device).upper().startswith("GPU")
+            and ov_precision == "device-default"
+        ):
+            sys.stderr.write(
+                f"OpenVINO: WARNING {os.path.basename(path)} requires "
+                f"inferencePrecision={config.get('gpuInferencePrecision')} on {ov_device}, "
+                "which does not list INFERENCE_PRECISION_HINT — it runs at the device default "
+                "and its detections may be invalid\n"
+            )
         sys.stderr.flush()
         # An OpenVINO IR converted from ONNX can carry an UNNAMED output tensor
         # (e.g. `yolov8n-package`): `get_any_name()` then raises

package/python/postprocessors/test_yolo_seg_root.py

@@ -0,0 +1,109 @@
+"""D737 — a YOLO26-seg ROOT decodes its boxes exactly like the plain detector
+and keeps one mask per kept detection.
+
+Run like the other postprocessor tests:
+``PYTHONPATH=postprocessors:. python -m pytest postprocessors/`` from
+``packages/addon-pipeline/python``.
+"""
+import base64
+
+import numpy as np
+
+from postprocessors.yolo import postprocess_yolo
+from postprocessors.yolo_seg import postprocess_yolo_seg
+
+LABELS = ["person", "car", "dog"]
+CONFIG = {"labels": LABELS, "numClasses": 3, "confidence": 0.3, "inputSize": 64}
+# A 1280x720 frame letterboxed into 64: scale 0.05, vertical pad 14.
+ORIG_W, ORIG_H, SCALE, PAD = 1280, 720, 0.05, (0, 14)
+PROTO = 16  # P x P prototype grid at the 64 input (4 px per cell)
+
+
+def _protos(rng: np.random.Generator) -> np.ndarray:
+    return rng.normal(size=(1, 32, PROTO, PROTO)).astype(np.float32)
+
+
+def _post_nms_rows(rng: np.random.Generator) -> np.ndarray:
+    """[1, 6, 38]: two overlapping persons (the end-to-end head keeps both),
+    a car, one row under the floor and two padding rows (class -1)."""
+    boxes = [
+        [8, 20, 24, 44, 0.91, 0],
+        [10, 22, 26, 46, 0.80, 0],
+        [30, 30, 56, 48, 0.66, 1],
+        [40, 18, 50, 28, 0.10, 2],
+        [0, 0, 0, 0, 0.0, -1],
+        [0, 0, 0, 0, 0.0, -1],
+    ]
+    coeffs = rng.normal(size=(len(boxes), 32))
+    return np.concatenate([np.array(boxes, dtype=np.float32), coeffs], axis=1)[None].astype(np.float32)
+
+
+def _raw_head(rng: np.random.Generator) -> np.ndarray:
+    """[1, 4 + 3 + 32, 5] with LOGIT scores (YOLO26 raw), two overlapping."""
+    cxcywh = np.array(
+        [[16, 32, 16, 24], [18, 34, 16, 24], [43, 39, 26, 18], [45, 23, 10, 10], [5, 5, 4, 4]],
+        dtype=np.float32,
+    ).T
+    logits = np.array(
+        [[3.0, 2.0, -4, -4, -6], [-4, -4, 1.5, -4, -6], [-4, -4, -4, -2.0, -6]], dtype=np.float32
+    )
+    coeffs = rng.normal(size=(32, 5)).astype(np.float32)
+    return np.concatenate([cxcywh, logits, coeffs], axis=0)[None]
+
+
+def _boxes(out: dict) -> list[tuple]:
+    return [(d["class"], d["score"], tuple(d["bbox"])) for d in out["detections"]]
+
+
+def test_post_nms_head_boxes_equal_the_plain_detectors():
+    rng = np.random.default_rng(1)
+    rows = _post_nms_rows(rng)
+    plain = postprocess_yolo({"output0": rows[..., :6].copy()}, dict(CONFIG), ORIG_W, ORIG_H, SCALE, PAD)
+    seg = postprocess_yolo_seg(
+        {"output0": rows, "output1": _protos(rng)}, dict(CONFIG), ORIG_W, ORIG_H, SCALE, PAD
+    )
+    assert _boxes(seg) == _boxes(plain)
+    # The plain detector does not NMS an end-to-end head; neither does the seg root.
+    assert len(seg["detections"]) == 3
+
+
+def test_raw_head_boxes_equal_the_plain_detectors():
+    rng = np.random.default_rng(2)
+    head = _raw_head(rng)
+    plain = postprocess_yolo({"output0": head[:, :7, :].copy()}, dict(CONFIG), ORIG_W, ORIG_H, SCALE, PAD)
+    seg = postprocess_yolo_seg(
+        {"output0": head.copy(), "output1": _protos(rng)}, dict(CONFIG), ORIG_W, ORIG_H, SCALE, PAD
+    )
+    assert _boxes(seg) == _boxes(plain)
+    assert len(seg["detections"]) == 2  # the overlap is suppressed, the floor drops two
+
+
+def test_same_nms_iou_knob_as_the_plain_detector():
+    rng = np.random.default_rng(3)
+    head = _raw_head(rng)
+    loose = dict(CONFIG, nmsIouThreshold=0.95)
+    plain = postprocess_yolo({"output0": head[:, :7, :].copy()}, loose, ORIG_W, ORIG_H, SCALE, PAD)
+    seg = postprocess_yolo_seg(
+        {"output0": head.copy(), "output1": _protos(rng)}, loose, ORIG_W, ORIG_H, SCALE, PAD
+    )
+    assert _boxes(seg) == _boxes(plain)
+    assert len(seg["detections"]) == 3
+
+
+def test_every_kept_detection_carries_its_own_mask_over_its_box():
+    rng = np.random.default_rng(4)
+    rows = _post_nms_rows(rng)
+    protos = _protos(rng)
+    out = postprocess_yolo_seg({"output0": rows, "output1": protos}, dict(CONFIG), ORIG_W, ORIG_H, SCALE, PAD)
+    first = out["detections"][0]
+    # Box [8,20,24,44] in the 64 input → proto cells [2,5,6,11] → 4 x 6.
+    assert (first["maskWidth"], first["maskHeight"]) == (4, 6)
+    raw = np.frombuffer(base64.b64decode(first["mask"]), dtype=np.uint8)
+    assert raw.size == 4 * 6
+    assert set(np.unique(raw)) <= {0, 255}
+    # The mask IS sigmoid(coeffs @ protos) > 0.5 over that window, for this row.
+    logits = rows[0, 0, 6:] @ protos[0][:, 5:11, 2:6].reshape(32, -1)
+    expected = ((1 / (1 + np.exp(-logits))) > 0.5).astype(np.uint8) * 255
+    assert np.array_equal(raw, expected)
+    # Different rows → different coefficient vectors → masks are per instance.
+    assert out["detections"][1]["mask"] != first["mask"]

package/python/postprocessors/yolo.py

@@ -180,12 +180,28 @@ def _postprocess_yolo11_nms(
 
     Coordinates are in input pixel space (0..inputSize). Already post-NMS.
     """
+    rows = decode_yolo11_nms_rows(output, config, orig_w, orig_h, scale, pad)
+    return {"kind": "detections", "detections": [d for _, d in rows]}
+
+
+def decode_yolo11_nms_rows(
+    output: np.ndarray,
+    config: dict,
+    orig_w: int,
+    orig_h: int,
+    scale: float,
+    pad: tuple[int, int],
+) -> list[tuple[int, dict]]:
+    """The post-NMS box decode, each kept detection paired with its ROW in
+    ``output``. Only the first 6 columns are read, so a seg head's
+    ``[N, 6 + 32]`` rows decode exactly like the plain detector's ``[N, 6]``
+    (D737) and the row index finds the detection's mask coefficients."""
     conf_threshold = float(config.get("confidence", 0))
     labels = config.get("labels", COCO_80)
 
-    detections = []
+    detections: list[tuple[int, dict]] = []
     for i in range(output.shape[0]):
-        x1, y1, x2, y2, score, class_id = output[i]
+        x1, y1, x2, y2, score, class_id = output[i][:6]
         score = float(score)
         if score < conf_threshold:
             continue
@@ -200,13 +216,13 @@ def _postprocess_yolo11_nms(
         oy2 = max(0, min(orig_h, (float(y2) - pad[1]) / scale))
 
         label = labels[class_id] if class_id < len(labels) else str(class_id)
-        detections.append({
+        detections.append((i, {
             "class": label,
             "score": round(score, 4),
             "bbox": [round(ox1, 1), round(oy1, 1), round(ox2, 1), round(oy2, 1)],
-        })
+        }))
 
-    return {"kind": "detections", "detections": detections}
+    return detections
 
 
 def postprocess_yolo(
@@ -223,12 +239,8 @@ def postprocess_yolo(
     1. Raw tensor (ONNX/OpenVINO): [4+numClasses, numBoxes] — needs NMS
     2. CoreML built-in NMS: 'confidence' + 'coordinates' tensors — already post-NMS
     """
-    conf_threshold = float(config.get("confidence", 0))
     labels = config.get("labels", COCO_80)
     num_classes = config.get("numClasses", len(labels))
-    # NMS IoU from the step config (operator slider); the 0.45 literal stays as
-    # the fallback so an unset value is byte-identical to today (#4).
-    nms_iou = float(config.get("nmsIouThreshold", 0.45))
 
     yolox = yolox_head_to_v8(predictions, int(config.get("inputSize", 640)))
     if yolox is not None:
@@ -272,6 +284,31 @@ def postprocess_yolo(
         else:
             output = output.T
 
+    rows = decode_raw_yolo_columns(output, config, orig_w, orig_h, scale, pad)
+    return {"kind": "detections", "detections": [d for _, d in rows]}
+
+
+def decode_raw_yolo_columns(
+    output: np.ndarray,
+    config: dict,
+    orig_w: int,
+    orig_h: int,
+    scale: float,
+    pad: tuple[int, int],
+) -> list[tuple[int, dict]]:
+    """The raw-head box decode (``[4 + numClasses (+ extra), numBoxes]``, one
+    COLUMN per candidate): sigmoid when the scores are logits, confidence
+    floor, NMS. Each kept detection is paired with its column in ``output``.
+    Rows past ``4 + numClasses`` are never read, so a seg head's mask
+    coefficients ride along untouched and decode exactly like the plain
+    detector (D737). May apply the sigmoid IN PLACE on the class rows."""
+    conf_threshold = float(config.get("confidence", 0))
+    labels = config.get("labels", COCO_80)
+    num_classes = config.get("numClasses", len(labels))
+    # NMS IoU from the step config (operator slider); the 0.45 literal stays as
+    # the fallback so an unset value is byte-identical to today (#4).
+    nms_iou = float(config.get("nmsIouThreshold", 0.45))
+
     num_boxes = output.shape[1]
 
     # Detect if scores are raw logits (YOLO11/v26) vs sigmoid-activated (YOLOv8/v9).
@@ -290,7 +327,7 @@ def postprocess_yolo(
     best_scores = class_scores[best_classes, np.arange(num_boxes)]  # (N,)
     mask = best_scores >= conf_threshold
     if not np.any(mask):
-        return {"kind": "detections", "detections": []}
+        return []
 
     # Gather only above-threshold boxes
     idxs = np.nonzero(mask)[0]
@@ -315,11 +352,13 @@ def postprocess_yolo(
             "score": round(float(sc[k]), 4),
             "bbox": [round(float(x1[k]), 1), round(float(y1[k]), 1), round(float(x2[k]), 1), round(float(y2[k]), 1)],
             "_xyxy": (float(x1[k]), float(y1[k]), float(x2[k]), float(y2[k])),
+            "_col": int(idxs[k]),
         })
 
     kept = _nms(candidates, nms_iou)
-    # Remove internal _xyxy field
+    # Remove the internal fields; the column travels beside the detection.
+    out: list[tuple[int, dict]] = []
     for d in kept:
         del d["_xyxy"]
-
-    return {"kind": "detections", "detections": kept}
+        out.append((d.pop("_col"), d))
+    return out