@camstack/addon-pipeline 1.2.608 → 1.2.610

package/dist/stream-broker/{_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-CWLQBK5e.mjs → _virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-BypETcj_.mjs}

@@ -3,7 +3,7 @@ import "./dist-CYZr2fwk.mjs";
 var e = {
 	"@camstack/sdk": {
 		name: "@camstack/sdk",
-		version: "1.2.140",
+		version: "1.2.142",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_stream_broker_widgets",
@@ -18,7 +18,7 @@ var e = {
 	},
 	"@camstack/types": {
 		name: "@camstack/types",
-		version: "1.2.390",
+		version: "1.2.392",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_stream_broker_widgets",
@@ -33,7 +33,7 @@ var e = {
 	},
 	"@camstack/ui-library": {
 		name: "@camstack/ui-library",
-		version: "1.2.307",
+		version: "1.2.309",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_stream_broker_widgets",

package/dist/stream-broker/{hostInit-BmdaGy6X.mjs → hostInit-DvGKmNcA.mjs}

@@ -36,7 +36,7 @@ async function r() {
 				}
 			},
 			"@camstack/types": {
-				version: "1.2.390",
+				version: "1.2.392",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,
@@ -45,7 +45,7 @@ async function r() {
 				}
 			},
 			"@camstack/sdk": {
-				version: "1.2.140",
+				version: "1.2.142",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,
@@ -81,7 +81,7 @@ async function r() {
 				}
 			},
 			"@camstack/ui-library": {
-				version: "1.2.307",
+				version: "1.2.309",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,

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-CWLQBK5e.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-BypETcj_.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

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

package/python/edgetpu_device.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 import ctypes
 import os
 import re
-from typing import Callable, Optional
+from typing import Callable, Mapping, Optional
 
 _DEVICE = re.compile(r"^(usb|pci)(:\d+)?$")
 
@@ -32,6 +32,37 @@ def edgetpu_delegate_options(device: Optional[str]) -> Optional[dict[str, str]]:
     return {"device": dev}
 
 
+# Where the hub image's installer has always put the delegate.
+LEGACY_EDGETPU_LIB = "/data/deps/edgetpu/lib/libedgetpu.so.1"
+
+
+def edgetpu_library_path(
+    env: "Mapping[str, str]",
+    platform: str,
+    exists: Optional[Callable[[str], bool]] = None,
+) -> str:
+    """The libedgetpu file this pool loads.
+
+    The same lookup as the TS probe (``chooseEdgetpuDelegate`` in
+    ``@camstack/types`` ``deps/edgetpu-delegate.ts``): ``CAMSTACK_EDGETPU_LIB``
+    when set (followed even if missing — ``load_delegate`` then names it); the
+    copy the deps downloader staged under ``<CAMSTACK_DATA>/deps/edgetpu/lib/``
+    (``libedgetpu.1.dylib`` on macOS, ``libedgetpu.so.1`` elsewhere); else the
+    hub's historical path, which on the hub image is the same file.
+    """
+    check = exists or os.path.exists
+    override = (env.get("CAMSTACK_EDGETPU_LIB") or "").strip()
+    if override:
+        return override
+    data_root = env.get("CAMSTACK_DATA") or env.get("CAMSTACK_DATA_DIR") or ""
+    if data_root:
+        name = "libedgetpu.1.dylib" if platform == "darwin" else "libedgetpu.so.1"
+        staged = os.path.join(data_root, "deps", "edgetpu", "lib", name)
+        if check(staged):
+            return staged
+    return LEGACY_EDGETPU_LIB
+
+
 # The libedgetpu "std" delegate links libusb even when it drives a PCIe Coral.
 # The installer (edgetpu-install.sh) drops this copy beside the delegate for an
 # image that lacks the system package.

package/python/inference_pool.py

@@ -830,12 +830,12 @@ def _init_runtime(runtime: str, device: str = "") -> None:
         # The delegate is created ONCE here and shared across all model slots (the
         # USB device is a single hardware context). See docs: the delegate's TF
         # version MUST match the interpreter — feranick libedgetpu tf2.17.1 pairs
-        # with ai-edge-litert 2.1.6. Install: /data/deps/edgetpu-install.sh.
+        # with ai-edge-litert 2.1.6. Staged by the deps downloader beside the
+        # edgetpu requirements (`requirements-edgetpu.txt`), or edgetpu-install.sh.
         import threading
         from ai_edge_litert.interpreter import Interpreter, load_delegate
-        lib_path = os.environ.get(
-            "CAMSTACK_EDGETPU_LIB", "/data/deps/edgetpu/lib/libedgetpu.so.1",
-        )
+        from edgetpu_device import edgetpu_library_path
+        lib_path = edgetpu_library_path(os.environ, sys.platform)
         # Multiple Corals (USB and/or PCIe) coexist and run concurrently, one
         # pool each. libedgetpu addresses a unit by device string; the TS side
         # sends the explicit ordinal ("usb:0", "usb:1", "pci:0", "pci:1") as the

package/python/postprocessors/test_yolov9_edgetpu_concat.py

@@ -0,0 +1,145 @@
+"""YOLOv9 Edge TPU build with ALL strides concatenated (the community Frigate export).
+
+The EdgeTPU-compiled YOLOv9 detectors the Frigate community publishes
+(`dbro/frigate-detector-edgetpu-yolo9`, releases v1.0 and v1.5) were read with
+a flatbuffer dump of the files themselves (2026-10-22):
+
+  yolov9-s-relu6-best_320_int8_edgetpu.tflite (v1.0)
+    in : serving_default_images:0  [1, 320, 320, 3] uint8  scale 1/255 zp 0
+    out: PartitionedCall:1          [1, 2100, 17]   int8   scale 0.027195 zp 19   (class LOGITS)
+         PartitionedCall:0          [1, 2100, 64]   int8   scale 0.079690 zp -45  (DFL l,t,r,b × 16)
+  yolov9-s-relu6-tpumax_512_int8_edgetpu.tflite (v1.5)
+    out: [1, 5376, 64] int8, [1, 5376, 17] int8, and a THIRD [1, 5376, 1] int8
+
+N is the three strides CONCATENATED, 8 then 16 then 32, each row-major
+(2100 = 40² + 20² + 10²; 5376 = 64² + 32² + 16²) — not one tensor pair per
+stride like the Scrypted export `test_yolo_split_dfl.py` pins. The anchor of
+cell (gx, gy) is ((gx + 0.5) · s, (gy + 0.5) · s); a box is anchor ∓ ltrb · s.
+
+Every fixture below is QUANTISED with the real file's scale/zero-point and
+dequantised through `edgetpu_dequant` exactly as the pool's edgetpu predict
+closure does; the expected boxes are computed by hand in the comments.
+
+Pure lists — runs on CI's bare interpreter (no numpy).
+"""
+from __future__ import annotations
+
+import math
+import os
+import sys
+import unittest
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.dirname(_HERE))  # edgetpu_dequant lives one level up
+
+from edgetpu_dequant import dequant_edgetpu_output  # noqa: E402
+from yolo_split_dfl import postprocess_yolo_split_dfl  # noqa: E402
+
+# The real quantisation of yolov9-s-relu6-best_320_int8_edgetpu.tflite.
+CLS_SCALE, CLS_ZP = 0.027195103466510773, 19
+BOX_SCALE, BOX_ZP = 0.07969039678573608, -45
+
+COCO17 = [
+    "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck",
+    "boat", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear",
+]
+
+Q_HOT, Q_COLD = 127, -128  # int8 extremes: DFL bin logits 13.7 / -6.6 after dequant
+
+
+def _dfl(l: int, t: int, r: int, b: int) -> list[int]:
+    out: list[int] = []
+    for bin_index in (l, t, r, b):
+        out += [Q_HOT if i == bin_index else Q_COLD for i in range(16)]
+    return out
+
+
+def _sigmoid(q: int) -> float:
+    return 1.0 / (1.0 + math.exp(-((q - CLS_ZP) * CLS_SCALE)))
+
+
+def _quantised_outputs(cells: dict[int, tuple[tuple[int, int, int, int], int, int]], n: int) -> tuple[list, list]:
+    """cells: candidate index → (ltrb bins, class id, quantised class logit)."""
+    box = [[_dfl(0, 0, 0, 0) for _ in range(n)]]
+    cls = [[[Q_COLD] * len(COCO17) for _ in range(n)]]
+    for idx, (ltrb, class_id, q) in cells.items():
+        box[0][idx] = _dfl(*ltrb)
+        cls[0][idx][class_id] = q
+    return box, cls
+
+
+def _dequant_cls(cls: list) -> list:
+    return dequant_edgetpu_output(cls, dtype_name="int8", scale=CLS_SCALE, zero_point=CLS_ZP)
+
+
+def _dequant_box(box: list) -> list:
+    return dequant_edgetpu_output(box, dtype_name="int8", scale=BOX_SCALE, zero_point=BOX_ZP)
+
+
+CONFIG = {
+    "labels": COCO17,
+    "confidence": 0.5,
+    "preprocessMode": "letterbox",
+    "inputSize": 320,
+    "inputWidth": 320,
+    "inputHeight": 320,
+    "nmsIouThreshold": 0.45,
+}
+
+# 640×480 frame letterboxed to 320: scale 0.5, content 320×240, pad (0, 40).
+ORIG_W, ORIG_H, SCALE, PAD = 640, 480, 0.5, (0, 40)
+
+# Stride 16 (grid 20, offset 40² = 1600), cell (gx 5, gy 7) → idx 1600 + 7·20 + 5 = 1745.
+#   anchor (5.5·16, 7.5·16) = (88, 120); ltrb (2, 3, 4, 1) → (56, 72)-(152, 136) input px
+#   → original ((56-0)/0.5, (72-40)/0.5, (152-0)/0.5, (136-40)/0.5) = (112, 64, 304, 192). car.
+CAR_IDX, CAR_Q = 1745, 99
+# Its neighbour (gx 6) → idx 1746, anchor (104, 120); ltrb (3, 3, 3, 1) → the SAME box,
+# a weaker score: NMS must keep only the car above.
+DUP_IDX, DUP_Q = 1746, 60
+# Stride 32 (grid 10, offset 1600 + 400 = 2000), cell (gx 3, gy 2) → idx 2000 + 2·10 + 3 = 2023.
+#   anchor (3.5·32, 2.5·32) = (112, 80); ltrb (1, 1, 2, 2) → (80, 48)-(176, 144) input px
+#   → original (160, 16, 352, 208). person.
+PERSON_IDX, PERSON_Q = 2023, 127
+
+CELLS = {
+    CAR_IDX: ((2, 3, 4, 1), 2, CAR_Q),
+    DUP_IDX: ((3, 3, 3, 1), 2, DUP_Q),
+    PERSON_IDX: ((1, 1, 2, 2), 0, PERSON_Q),
+}
+
+
+class YoloV9EdgeTpuConcatenatedStrides(unittest.TestCase):
+    def _decode(self, predictions: dict) -> list[dict]:
+        out = postprocess_yolo_split_dfl(predictions, CONFIG, ORIG_W, ORIG_H, SCALE, PAD)
+        self.assertEqual(out["kind"], "detections")
+        return sorted(out["detections"], key=lambda d: d["class"])
+
+    def _assert_expected(self, dets: list[dict]) -> None:
+        self.assertEqual([d["class"] for d in dets], ["car", "person"])
+        car, person = dets
+        self.assertEqual(car["bbox"], [112.0, 64.0, 304.0, 192.0])
+        self.assertEqual(person["bbox"], [160.0, 16.0, 352.0, 208.0])
+        self.assertEqual(car["score"], round(_sigmoid(CAR_Q), 4))
+        self.assertEqual(person["score"], round(_sigmoid(PERSON_Q), 4))
+
+    def test_v1_0_two_tensors_scores_first(self) -> None:
+        box, cls = _quantised_outputs(CELLS, 2100)
+        # Positional keys in the file's output order: scores, then boxes.
+        self._assert_expected(self._decode({"0": _dequant_cls(cls), "1": _dequant_box(box)}))
+
+    def test_v1_5_third_single_channel_tensor_is_not_the_class_tensor(self) -> None:
+        box, cls = _quantised_outputs(CELLS, 2100)
+        # The v1.5 files add a [1, N, 1] output AFTER the class tensor. Read as the
+        # class tensor it would score every candidate on ONE cold channel.
+        aux = [[[Q_COLD] for _ in range(2100)]]
+        preds = {"0": _dequant_box(box), "1": _dequant_cls(cls), "2": _dequant_cls(aux)}
+        self._assert_expected(self._decode(preds))
+
+    def test_a_concatenated_n_that_matches_no_input_size_is_refused(self) -> None:
+        box, cls = _quantised_outputs({}, 2101)
+        with self.assertRaises(ValueError):
+            self._decode({"0": _dequant_cls(cls), "1": _dequant_box(box)})
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/postprocessors/yolo_split_dfl.py

@@ -1,10 +1,20 @@
-"""YOLO split-head DFL postprocessor (Scrypted YOLOv9 TFLite / EdgeTPU).
+"""YOLO split-head DFL postprocessor (YOLOv9 TFLite / EdgeTPU).
 
-Scrypted's TFLite builds emit SIX tensors (3 strides × box+cls), not the
-ONNX ``[1, 7, 2100]`` packed layout:
+Two split layouts reach it, neither the ONNX ``[1, 7, 2100]`` packed one:
 
-  box: [1, H·W, 4·reg_max] with ``reg_max=16`` (DFL distances l,t,r,b)
-  cls: [1, H·W, C]          logits over person/vehicle/animal (C=3)
+* Scrypted's TFLite builds emit SIX tensors (3 strides × box+cls):
+
+    box: [1, H·W, 4·reg_max] with ``reg_max=16`` (DFL distances l,t,r,b)
+    cls: [1, H·W, C]          logits over person/vehicle/animal (C=3)
+
+* The community Frigate EdgeTPU export (``dbro/frigate-detector-edgetpu-yolo9``,
+  read from the published files) emits ONE pair with the strides
+  CONCATENATED, 8 then 16 then 32, each row-major:
+
+    box: [1, N, 64]  cls: [1, N, C]   N = Σ (H/s)·(W/s) — 2100 at 320², 5376 at 512²
+
+  and its v1.5 files add a third ``[1, N, 1]`` tensor that is NOT the class
+  tensor: the widest non-box tensor of a given ``N`` is.
 
 Pairs are matched by shared spatial length ``N`` (1600/400/100 for 320²), not
 by positional key order — TFLite output order has drifted between exports.
@@ -110,7 +120,10 @@ def _pair_box_cls(predictions: dict) -> list[tuple[Any, Any]]:
         n, width = shape
         if width == 4 * REG_MAX:
             boxes[n] = tensor
-        elif width > 0 and width != 4 * REG_MAX:
+        elif width > 0 and (n not in classes or width > _shape(classes[n])[1]):
+            # The WIDEST non-box tensor of this N is the class tensor: a
+            # one-channel sibling (the v1.5 Frigate export's [1, N, 1]) never
+            # displaces it, whatever the output order.
             classes[n] = tensor
     pairs: list[tuple[Any, Any]] = []
     for n, box in boxes.items():
@@ -128,6 +141,37 @@ def _pair_box_cls(predictions: dict) -> list[tuple[Any, Any]]:
     return pairs
 
 
+CONCAT_STRIDES: tuple[int, ...] = (8, 16, 32)
+
+
+def _concat_stride_cells(n: int, in_w: int, in_h: int) -> "list[tuple[int, int, int]] | None":
+    """``[(offset, stride, grid_w), …]`` when ``N`` is every stride of the input
+    concatenated (8, 16, 32 in that order), else ``None``."""
+    cells: list[tuple[int, int, int]] = []
+    offset = 0
+    for stride in CONCAT_STRIDES:
+        if in_w % stride or in_h % stride:
+            return None
+        cells.append((offset, stride, in_w // stride))
+        offset += (in_w // stride) * (in_h // stride)
+    return cells if offset == n else None
+
+
+def _segments(
+    box: Any, cls: Any, in_w: int, in_h: int, input_size: int
+) -> list[tuple[Any, Any, int, int]]:
+    """``(box rows, cls rows, stride, grid_w)`` per stride of one box/cls pair."""
+    n = _shape(box)[0]
+    concat = _concat_stride_cells(n, in_w, in_h)
+    if concat is None:
+        return [(box, cls, _infer_stride(n, input_size), int(round(math.sqrt(n))))]
+    ends = [offset for offset, _, _ in concat[1:]] + [n]
+    return [
+        (box[offset:end], cls[offset:end], stride, grid_w)
+        for (offset, stride, grid_w), end in zip(concat, ends)
+    ]
+
+
 def _infer_stride(n: int, input_size: int) -> int:
     """N = (input_size / stride)² → stride = input_size / sqrt(N)."""
     side = int(round(math.sqrt(n)))
@@ -191,12 +235,17 @@ def postprocess_yolo_split_dfl(
     labels = config.get("labels") or ["person", "vehicle", "animal"]
     nms_iou = float(config.get("nmsIouThreshold", 0.45))
     input_size = int(config.get("inputSize") or config.get("inputWidth") or 320)
+    in_w = int(config.get("inputWidth") or input_size)
+    in_h = int(config.get("inputHeight") or input_size)
 
+    segments = [
+        seg
+        for box_pair, cls_pair in _pair_box_cls(predictions)
+        for seg in _segments(box_pair, cls_pair, in_w, in_h, input_size)
+    ]
     candidates: list[dict] = []
-    for box_tensor, cls_tensor in _pair_box_cls(predictions):
+    for box_tensor, cls_tensor, stride, grid in segments:
         n = _shape(box_tensor)[0]
-        stride = _infer_stride(n, input_size)
-        grid = int(round(math.sqrt(n)))
         num_classes = _shape(cls_tensor)[1]
 
         for i in range(n):

package/python/requirements-edgetpu.txt

@@ -9,16 +9,19 @@
 #     and is numpy-2 native.
 ai-edge-litert==2.1.6
 
-# libedgetpu.so.1 (the Coral delegate) is a SYSTEM shared library — pip cannot
-# install it. It MUST be provided out-of-band and its TensorFlow version MUST
-# match the interpreter (stock Coral libedgetpu 16.0/grouper is built against old
-# TFLite and FAILS at invoke: "EdgeTpuDelegateForCustomOp failed to invoke").
-# The hub uses feranick's libedgetpu rebuilt against TF 2.17.1 (std/throttled),
-# installed under /data/deps/edgetpu/lib/libedgetpu.so.1 by the installer that
-# ships beside this file, `edgetpu-install.sh` (it also drops libusb-1.0.so.0
-# there: the std delegate links libusb even for a PCIe Coral, and the pool
-# preloads that copy). The path is overridable via the CAMSTACK_EDGETPU_LIB env
-# var (default /data/deps/edgetpu/lib/libedgetpu.so.1).
+# libedgetpu (the Coral delegate) is a native shared library — pip cannot
+# install it — and its TensorFlow version MUST match the interpreter (stock
+# Coral libedgetpu 16.0/grouper is built against old TFLite and FAILS at invoke:
+# "EdgeTpuDelegateForCustomOp failed to invoke"). The line below asks the deps
+# downloader to stage feranick's libedgetpu rebuilt against TF 2.17.1 right
+# after this file installs (`@camstack/types` `deps/edgetpu-delegate.ts`:
+# pinned, SHA-256 verified; on Linux libusb-1.0.so.0 beside it, because the std
+# delegate links libusb even for a PCIe Coral and the pool preloads that copy).
+# It lands in <CAMSTACK_DATA>/deps/edgetpu/lib/ — /data/deps/edgetpu/lib on the
+# hub image, where `edgetpu-install.sh` (beside this file) has always put it.
+# Linux x64/arm64 and Apple Silicon only; Windows has no TF 2.17.1 build.
+# CAMSTACK_EDGETPU_LIB overrides the path the pool loads.
+# camstack-native-dep: edgetpu-delegate
 #
 # Host prerequisite, USB: /dev/bus/usb passed through plus a
 # `--device-cgroup-rule 'c 189:* rmw'` rule (the Coral re-enumerates its USB

package/python/test_edgetpu_device.py

@@ -14,7 +14,7 @@ import tempfile
 import unittest
 from unittest import mock
 
-from edgetpu_device import edgetpu_delegate_options, preload_libusb
+from edgetpu_device import edgetpu_delegate_options, edgetpu_library_path, preload_libusb
 
 
 class EdgetpuDelegateOptions(unittest.TestCase):
@@ -70,5 +70,34 @@ class PreloadLibusb(unittest.TestCase):
             cdll.assert_called_once_with(path, mode=ctypes.RTLD_GLOBAL)
 
 
+class EdgetpuLibraryPath(unittest.TestCase):
+    """The delegate the pool loads — the same lookup as the TS probe
+    (`chooseEdgetpuDelegate` in `@camstack/types`): override, then the copy
+    staged under the node data root, then the hub's historical path."""
+
+    LEGACY = "/data/deps/edgetpu/lib/libedgetpu.so.1"
+
+    def test_a_desktop_loads_the_dylib_staged_under_its_data_root(self) -> None:
+        staged = "/Users/me/CamStack/data/deps/edgetpu/lib/libedgetpu.1.dylib"
+        path = edgetpu_library_path(
+            {"CAMSTACK_DATA": "/Users/me/CamStack/data"}, "darwin", lambda p: p == staged
+        )
+        self.assertEqual(path, staged)
+
+    def test_a_linux_agent_with_another_data_root_loads_its_staged_copy(self) -> None:
+        staged = "/srv/cs/deps/edgetpu/lib/libedgetpu.so.1"
+        env = {"CAMSTACK_DATA_DIR": "/srv/cs"}
+        self.assertEqual(edgetpu_library_path(env, "linux", lambda p: p in (staged, self.LEGACY)), staged)
+
+    def test_the_override_wins_even_when_missing(self) -> None:
+        # The operator named a file: loading another build instead would hide it.
+        env = {"CAMSTACK_EDGETPU_LIB": "/opt/x.so", "CAMSTACK_DATA": "/d"}
+        self.assertEqual(edgetpu_library_path(env, "linux", lambda p: False), "/opt/x.so")
+
+    def test_nothing_staged_falls_back_to_the_historical_hub_path(self) -> None:
+        self.assertEqual(edgetpu_library_path({}, "linux", lambda p: False), self.LEGACY)
+        self.assertEqual(edgetpu_library_path({"CAMSTACK_DATA": "/d"}, "linux", lambda p: False), self.LEGACY)
+
+
 if __name__ == "__main__":
     unittest.main()