@camstack/addon-pipeline 1.2.325 → 1.2.327

package/dist/stream-broker/{hostInit-C_x1pkx-.mjs → hostInit-Cg4IdtE5.mjs}

@@ -36,7 +36,7 @@ async function r() {
 				}
 			},
 			"@camstack/types": {
-				version: "1.2.303",
+				version: "1.2.305",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,
@@ -45,7 +45,7 @@ async function r() {
 				}
 			},
 			"@camstack/sdk": {
-				version: "1.2.120",
+				version: "1.2.121",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,
@@ -81,7 +81,7 @@ async function r() {
 				}
 			},
 			"@camstack/ui-library": {
-				version: "1.2.230",
+				version: "1.2.232",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,

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-DlgXwnqU.js");
-const require_node = require("../node-s3wZnnJg.js");
+const require_dist = require("../dist-BBZwYfSN.js");
+const require_node = require("../node-mJQBUiEc.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-BbM0_Fmz.js");
+const require_segment_demux_js = require("../segment-demux-js-C2ufKMu0.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_crypto = require("node:crypto");
@@ -9791,9 +9791,9 @@ function extractAudioTrack(parsed) {
 * Resolve a track control URL against the session-level control / RTSP base URL.
 *
 * Cameras vary wildly:
-* - Absolute: "rtsp://192.168.x.x/trackID=1"
+* - Absolute: "rtsp://192.168.10.100/trackID=1"
 * - Relative: "trackID=1" or "track1"
-* - Session control: "rtsp://192.168.x.x/stream1" with track "trackID=1"
+* - Session control: "rtsp://192.168.10.100/stream1" with track "trackID=1"
 */
 function resolveTrackUrl(baseUrl, sessionControl, trackControl) {
 	if (!trackControl) return baseUrl;

package/dist/stream-broker/index.mjs

@@ -1,10 +1,10 @@
 import { r as __toESM } from "../chunk-DnnnRqeS.mjs";
-import { $ as declareLogChannel, Bn as record, Cn as isEvent, Ct as maskUrlCredentials, En as nodePin, Et as memoizePinnedFfmpeg, H as addonWidgetsSourceCapability, Hn as union, In as literal, J as cameraStreamsCapability, K as batteryCapability, Ln as number, Lt as rankStreams, M as RATE_CONTROL_TIGHT, Mn as array, Nn as boolean, On as parseProfileBrokerId, Pn as discriminatedUnion, Q as createLogChannelsProvider, Qt as streamBrokerCapability, R as RingBuffer, Rn as object, S as EncodeProfileSchema, T as G711_SCALE_CORRECTION_DB, Tn as makeSourceBrokerId, Un as EventCategory, Vn as string, Wt as resolveEgressDecodeHwAccel, X as clipExportFailureOf, Z as createHwAccelCache, at as egressTranscodeSharingKey, bt as loadContributionCapability, c as CLIP_STILL_REASON_CODE_HEADER, cn as invocationFromEncodeProfile, dn as DeviceType, fn as errMsg, gn as CamProfileSchema, gt as gifFromMp4Args, hn as CAM_PROFILE_ORDER, ht as gifDeriveSpeed, j as RATE_CONTROL_RELAXED, jn as _enum, ln as isSoftwareDecode, mn as BaseAddon, nn as webrtcSessionCapability, o as BatteryStatusSchema, on as buildFfmpegArgs$1, ot as egressTransportFromRequest, pn as BOOT_RECOVERY_BACKOFF_MS, pt as ffmpegRate, rn as AUDIO_PRESETS, s as CLIP_BROKER_PACED_RATES, tt as deriveBatteryPresence, un as DeviceFeature, vn as createEvent, wn as makeProfileBrokerId, xn as expandAudioChunkToF32le, xt as logChannelsCapability } from "../dist-CbRb0Zyj.mjs";
-import { i as NO_COST_CLAIM, n as Fmp4FragmentChild, o as probeFfmpegBinary, r as Fmp4FragmentPlane, t as ChildCostRegistry } from "../node-CZ5DXcvq.mjs";
+import { $ as declareLogChannel, Bn as record, Cn as isEvent, Ct as maskUrlCredentials, En as nodePin, Et as memoizePinnedFfmpeg, H as addonWidgetsSourceCapability, Hn as union, In as literal, J as cameraStreamsCapability, K as batteryCapability, Ln as number, Lt as rankStreams, M as RATE_CONTROL_TIGHT, Mn as array, Nn as boolean, On as parseProfileBrokerId, Pn as discriminatedUnion, Q as createLogChannelsProvider, Qt as streamBrokerCapability, R as RingBuffer, Rn as object, S as EncodeProfileSchema, T as G711_SCALE_CORRECTION_DB, Tn as makeSourceBrokerId, Un as EventCategory, Vn as string, Wt as resolveEgressDecodeHwAccel, X as clipExportFailureOf, Z as createHwAccelCache, at as egressTranscodeSharingKey, bt as loadContributionCapability, c as CLIP_STILL_REASON_CODE_HEADER, cn as invocationFromEncodeProfile, dn as DeviceType, fn as errMsg, gn as CamProfileSchema, gt as gifFromMp4Args, hn as CAM_PROFILE_ORDER, ht as gifDeriveSpeed, j as RATE_CONTROL_RELAXED, jn as _enum, ln as isSoftwareDecode, mn as BaseAddon, nn as webrtcSessionCapability, o as BatteryStatusSchema, on as buildFfmpegArgs$1, ot as egressTransportFromRequest, pn as BOOT_RECOVERY_BACKOFF_MS, pt as ffmpegRate, rn as AUDIO_PRESETS, s as CLIP_BROKER_PACED_RATES, tt as deriveBatteryPresence, un as DeviceFeature, vn as createEvent, wn as makeProfileBrokerId, xn as expandAudioChunkToF32le, xt as logChannelsCapability } from "../dist-B9LnBPz9.mjs";
+import { i as NO_COST_CLAIM, n as Fmp4FragmentChild, o as probeFfmpegBinary, r as Fmp4FragmentPlane, t as ChildCostRegistry } from "../node-Ci0E-0VP.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-CuwXgwpj.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-DzwHW4Ey.mjs";
 import { createRequire } from "node:module";
 import * as os from "node:os";
 import { networkInterfaces, tmpdir } from "node:os";
@@ -9787,9 +9787,9 @@ function extractAudioTrack(parsed) {
 * Resolve a track control URL against the session-level control / RTSP base URL.
 *
 * Cameras vary wildly:
-* - Absolute: "rtsp://192.168.x.x/trackID=1"
+* - Absolute: "rtsp://192.168.10.100/trackID=1"
 * - Relative: "trackID=1" or "track1"
-* - Session control: "rtsp://192.168.x.x/stream1" with track "trackID=1"
+* - Session control: "rtsp://192.168.10.100/stream1" with track "trackID=1"
 */
 function resolveTrackUrl(baseUrl, sessionControl, trackControl) {
 	if (!trackControl) return baseUrl;

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-pipeline",
-  "version": "1.2.325",
+  "version": "1.2.327",
   "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_dequant.py

@@ -0,0 +1,55 @@
+"""Dequant of EdgeTPU / TFLite integer output tensors.
+
+Kept free of numpy so the bare-interpreter CI path
+(``scripts/test-python-pool.sh``) can pin the contract. The edgetpu predict
+closure in ``inference_pool.py`` calls this for every output; float32 tensors
+(SSD ``TFLite_Detection_PostProcess``) pass through unchanged.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+
+def _is_integer_dtype(dtype_name: str) -> bool:
+    name = dtype_name.lower()
+    return name in ("uint8", "int8", "u8", "i8") or name.endswith("uint8") or name.endswith("int8")
+
+
+def dequant_edgetpu_output(
+    value: Any,
+    *,
+    dtype_name: str,
+    scale: float,
+    zero_point: int,
+) -> Any:
+    """Return ``value`` dequantised to float when it is an integer tensor.
+
+    ``value`` is a scalar, a nested list (``ndarray.tolist()``), or anything
+    that exposes ``tolist``. Float dtypes are returned unchanged. A zero or
+    missing scale becomes a plain float cast — we never invent a scale.
+    """
+    if hasattr(value, "tolist") and not isinstance(value, (list, tuple)):
+        # numpy / TFLite tensor — decide from dtype_name, then walk lists.
+        value = value.tolist()
+
+    if not _is_integer_dtype(dtype_name):
+        return value
+
+    if scale is None or float(scale) <= 0.0:
+        return _cast_floats(value)
+
+    s = float(scale)
+    zp = int(zero_point)
+    return _scale_tree(value, s, zp)
+
+
+def _cast_floats(value: Any) -> Any:
+    if isinstance(value, (list, tuple)):
+        return [_cast_floats(v) for v in value]
+    return float(value)
+
+
+def _scale_tree(value: Any, scale: float, zero_point: int) -> Any:
+    if isinstance(value, (list, tuple)):
+        return [_scale_tree(v, scale, zero_point) for v in value]
+    return (float(value) - zero_point) * scale

package/python/inference_pool.py

@@ -1413,14 +1413,30 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
 
         def predict(
             inp_dict: dict,
-            _interp=interp, _lock=lock, _in=in_index, _outs=out_index,
+            _interp=interp, _lock=lock, _in=in_index, _outs=out_index, _details=out_dets,
         ) -> dict:
+            from edgetpu_dequant import dequant_edgetpu_output
+
             tensor = next(iter(inp_dict.values()))
             with _lock:
                 _interp.set_tensor(_in, tensor)
                 _interp.invoke()
-                # Positional keys — the ssd postprocessor reads "0".."3".
-                return {str(i): _interp.get_tensor(idx) for i, idx in enumerate(_outs)}
+                # Positional keys — ssd reads "0".."3"; yolo-split-dfl pairs by
+                # shape. Integer outputs are dequantised here so every
+                # postprocessor sees float32 (SSD Detection_PostProcess is
+                # already float and passes through).
+                result = {}
+                for i, idx in enumerate(_outs):
+                    raw = _interp.get_tensor(idx)
+                    detail = _details[i]
+                    q = detail.get("quantization") or (0.0, 0)
+                    scale = float(q[0]) if q else 0.0
+                    zp = int(q[1]) if q else 0
+                    dtype_name = str(np.dtype(detail["dtype"]).name)
+                    result[str(i)] = dequant_edgetpu_output(
+                        raw, dtype_name=dtype_name, scale=scale, zero_point=zp
+                    )
+                return result
 
         slot.model = interp
         slot.predict_fn = predict

package/python/postprocessors/__init__.py

@@ -17,6 +17,7 @@ from .ssd import postprocess_ssd
 from .rfdetr import postprocess_rfdetr
 from .yolonas import postprocess_yolonas
 from .yunet import postprocess_yunet
+from .yolo_split_dfl import postprocess_yolo_split_dfl
 
 POSTPROCESSORS = {
     "yolo": postprocess_yolo,
@@ -33,4 +34,5 @@ POSTPROCESSORS = {
     "rfdetr": postprocess_rfdetr,
     "yolonas": postprocess_yolonas,
     "yunet": postprocess_yunet,
+    "yolo-split-dfl": postprocess_yolo_split_dfl,
 }

package/python/postprocessors/scrfd.py

@@ -10,6 +10,8 @@ module is now the sole SCRFD decoder in the repo.
 
 Output: {"kind": "detections", "detections": [{"class": "face", "score", "bbox": [x1,y1,x2,y2], "landmarks?"}]}
 """
+
+from __future__ import annotations
 import numpy as np
 
 

package/python/postprocessors/test_ssd.py

@@ -1,10 +1,9 @@
 """Pins the SSD decoder on REAL SSDLite MobileDet output tensors.
 
-`ssdlite-mobiledet-coco-edgetpu` joins the two Coral detectors that already use
-`postprocessor: 'ssd'`. Its graph ends in the same `TFLite_Detection_PostProcess`
-op, but nothing had checked that the decoder reads MobileDet's outputs the way
-the model writes them. Each class below pins one thing that could silently turn
-a working model into wrong labels or empty frames:
+The CamStack catalog keeps only `ssd-mobilenet-v2-coco-edgetpu`; Frigate still
+imports MobileDet. Both graphs end in `TFLite_Detection_PostProcess`, and this
+fixture (MobileDet outputs on two COCO val2017 frames) pins what the shared
+`postprocessor: 'ssd'` decoder must read correctly:
 
 - the output ORDER (boxes, classes, scores, count on positional keys "0".."3");
 - the class-index OFFSET (91 score columns, background dropped by the op, so
@@ -16,7 +15,7 @@ a working model into wrong labels or empty frames:
   confidence thresholds can ever pass.
 
 The fixture (`testdata/ssdlite_mobiledet_outputs.json`) holds the model's raw
-outputs on two COCO val2017 frames; its `_provenance` says how they were made.
+outputs; its `_provenance` says how they were made.
 
 `unittest.TestCase` with no numpy: `scripts/test-python-pool.sh` runs these on
 CI's bare interpreter, where numpy is absent, and `ssd.py` decodes plain lists

package/python/postprocessors/test_yolo_split_dfl.py

@@ -0,0 +1,135 @@
+"""yolo-split-dfl — Scrypted YOLOv9 TFLite 6-tensor DFL split-head decode.
+
+Scrypted's TFLite exports emit SIX tensors, not the ONNX ``[1, 7, 2100]`` layout:
+
+  box × strides: [1, N, 64]  (4 × reg_max=16 DFL)
+  cls × strides: [1, N, 3]   (person/vehicle/animal)
+
+Pure-list fixtures so CI's bare interpreter covers the math. A fixture of real
+Scrypted tensors can join later; fakes alone are not proof on Coral hardware.
+"""
+from __future__ import annotations
+
+import unittest
+
+from yolo_split_dfl import postprocess_yolo_split_dfl
+
+
+def _one_hot_dfl(bin_index: int, reg_max: int = 16) -> list[float]:
+    logits = [-20.0] * reg_max
+    logits[bin_index] = 20.0
+    return logits
+
+
+def _empty_box(n: int) -> list:
+    return [[[-20.0] * 64 for _ in range(n)]]
+
+
+def _empty_cls(n: int, num_classes: int = 3) -> list:
+    return [[[-20.0] * num_classes for _ in range(n)]]
+
+
+def _synthetic_predictions(
+    *,
+    grid: int,
+    cell_x: int,
+    cell_y: int,
+    ltrb: tuple[int, int, int, int],
+    class_id: int,
+    num_classes: int = 3,
+) -> dict:
+    n = grid * grid
+    box = _empty_box(n)
+    cls = _empty_cls(n, num_classes)
+    idx = cell_y * grid + cell_x
+    l, t, r, b = ltrb
+    box[0][idx] = _one_hot_dfl(l) + _one_hot_dfl(t) + _one_hot_dfl(r) + _one_hot_dfl(b)
+    cls[0][idx] = [-20.0] * num_classes
+    cls[0][idx][class_id] = 20.0
+
+    # Sibling empty strides + shuffled keys — decoder must pair by shared N.
+    return {
+        "0": _empty_box(400),
+        "1": box,
+        "2": _empty_box(100),
+        "3": _empty_cls(400),
+        "4": cls,
+        "5": _empty_cls(100),
+    }
+
+
+class YoloSplitDfl(unittest.TestCase):
+    def test_registered_in_dispatch_table_source(self) -> None:
+        # Loading ``postprocessors`` as a package needs the parent on sys.path
+        # and numpy for sibling imports (yolo.py). On the bare CI path we pin
+        # registration by reading the dispatch table source instead.
+        from pathlib import Path
+
+        init_src = (Path(__file__).resolve().parent / "__init__.py").read_text(encoding="utf-8")
+        self.assertIn('"yolo-split-dfl": postprocess_yolo_split_dfl', init_src)
+        self.assertIn("from .yolo_split_dfl import postprocess_yolo_split_dfl", init_src)
+
+    def test_decodes_dfl_box_on_resize_preprocess(self) -> None:
+        # Stride = 320/40 = 8. Cell (10,10) → centre 84,84.
+        # ltrb bins (2,2,2,2) → ±16 px → box (68,68)-(100,100) input space.
+        # resize on 640×480 → ×2 / ×1.5.
+        preds = _synthetic_predictions(
+            grid=40, cell_x=10, cell_y=10, ltrb=(2, 2, 2, 2), class_id=0
+        )
+        cfg = {
+            "labels": ["person", "vehicle", "animal"],
+            "confidence": 0.25,
+            "preprocessMode": "resize",
+            "inputSize": 320,
+            "inputWidth": 320,
+            "inputHeight": 320,
+            "nmsIouThreshold": 0.45,
+        }
+        out = postprocess_yolo_split_dfl(preds, cfg, 640, 480, 1.0, (0, 0))
+        self.assertEqual(out["kind"], "detections")
+        self.assertEqual(len(out["detections"]), 1)
+        det = out["detections"][0]
+        self.assertEqual(det["class"], "person")
+        self.assertGreater(det["score"], 0.9)
+        x1, y1, x2, y2 = det["bbox"]
+        self.assertAlmostEqual(x1, 68.0 * 640 / 320, places=0)
+        self.assertAlmostEqual(y1, 68.0 * 480 / 320, places=0)
+        self.assertAlmostEqual(x2, 100.0 * 640 / 320, places=0)
+        self.assertAlmostEqual(y2, 100.0 * 480 / 320, places=0)
+
+    def test_respects_confidence_floor(self) -> None:
+        preds = _synthetic_predictions(
+            grid=40, cell_x=5, cell_y=5, ltrb=(1, 1, 1, 1), class_id=1
+        )
+        cfg = {
+            "labels": ["person", "vehicle", "animal"],
+            "confidence": 0.99,
+            "preprocessMode": "resize",
+            "inputSize": 320,
+        }
+        preds["4"][0][5 * 40 + 5][1] = -5.0
+        out = postprocess_yolo_split_dfl(preds, cfg, 320, 320, 1.0, (0, 0))
+        self.assertEqual(out["detections"], [])
+
+    def test_letterbox_undo_when_scale_pad_provided(self) -> None:
+        preds = _synthetic_predictions(
+            grid=40, cell_x=10, cell_y=10, ltrb=(2, 2, 2, 2), class_id=2
+        )
+        cfg = {
+            "labels": ["person", "vehicle", "animal"],
+            "confidence": 0.25,
+            "preprocessMode": "letterbox",
+            "inputSize": 320,
+        }
+        out = postprocess_yolo_split_dfl(preds, cfg, 640, 480, 0.5, (0, 40))
+        det = out["detections"][0]
+        self.assertEqual(det["class"], "animal")
+        x1, y1, x2, y2 = det["bbox"]
+        self.assertAlmostEqual(x1, (68.0 - 0) / 0.5, places=0)
+        self.assertAlmostEqual(y1, (68.0 - 40) / 0.5, places=0)
+        self.assertAlmostEqual(x2, (100.0 - 0) / 0.5, places=0)
+        self.assertAlmostEqual(y2, (100.0 - 40) / 0.5, places=0)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/postprocessors/yolo_split_dfl.py

@@ -0,0 +1,255 @@
+"""YOLO split-head DFL postprocessor (Scrypted YOLOv9 TFLite / EdgeTPU).
+
+Scrypted's TFLite builds emit SIX tensors (3 strides × box+cls), not the
+ONNX ``[1, 7, 2100]`` packed layout:
+
+  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)
+
+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.
+Coordinates are decoded in INPUT pixel space, then mapped back to the original
+frame: stretch when ``preprocessMode == 'resize'`` (Scrypted default), else
+letterbox undo via the pool's ``scale`` + ``pad``.
+
+Pure nested lists so CI's bare interpreter (no numpy) still pins the math —
+same discipline as ``ssd.py``. A live ndarray from the pool is accepted via
+``.tolist()``.
+"""
+from __future__ import annotations
+
+import math
+from typing import Any
+
+REG_MAX = 16
+
+
+def _as_list(value: Any) -> Any:
+    return value.tolist() if hasattr(value, "tolist") else value
+
+
+def _shape(value: Any) -> tuple[int, ...]:
+    dims: list[int] = []
+    cur = value
+    while isinstance(cur, (list, tuple)):
+        dims.append(len(cur))
+        if not cur:
+            break
+        cur = cur[0]
+    return tuple(dims)
+
+
+def _sigmoid(x: float) -> float:
+    if x >= 0:
+        z = math.exp(-x)
+        return 1.0 / (1.0 + z)
+    z = math.exp(x)
+    return z / (1.0 + z)
+
+
+def _softmax(xs: list[float]) -> list[float]:
+    m = max(xs) if xs else 0.0
+    exps = [math.exp(x - m) for x in xs]
+    s = sum(exps) or 1.0
+    return [e / s for e in exps]
+
+
+def _dfl_distance(logits16: list[float]) -> float:
+    """Softmax over ``reg_max`` bins · project ``[0..reg_max)`` → distance in cells."""
+    probs = _softmax(logits16)
+    return sum(i * p for i, p in enumerate(probs))
+
+
+def _iou(a: tuple[float, float, float, float], b: tuple[float, float, float, float]) -> float:
+    ax1, ay1, ax2, ay2 = a
+    bx1, by1, bx2, by2 = b
+    ix1, iy1 = max(ax1, bx1), max(ay1, by1)
+    ix2, iy2 = min(ax2, bx2), min(ay2, by2)
+    inter = max(0.0, ix2 - ix1) * max(0.0, iy2 - iy1)
+    if inter <= 0:
+        return 0.0
+    area_a = max(0.0, ax2 - ax1) * max(0.0, ay2 - ay1)
+    area_b = max(0.0, bx2 - bx1) * max(0.0, by2 - by1)
+    union = area_a + area_b - inter
+    return inter / union if union > 0 else 0.0
+
+
+def _nms(boxes: list[dict], iou_threshold: float) -> list[dict]:
+    ordered = sorted(boxes, key=lambda b: b["score"], reverse=True)
+    kept: list[dict] = []
+    suppressed: set[int] = set()
+    for i, box in enumerate(ordered):
+        if i in suppressed:
+            continue
+        kept.append(box)
+        for j in range(i + 1, len(ordered)):
+            if j in suppressed:
+                continue
+            if _iou(box["_xyxy"], ordered[j]["_xyxy"]) > iou_threshold:
+                suppressed.add(j)
+    return kept
+
+
+def _squeeze_batch(tensor: Any) -> Any:
+    """Drop a leading batch dim of 1: [1, N, C] → [N, C]."""
+    shape = _shape(tensor)
+    if len(shape) == 3 and shape[0] == 1:
+        return tensor[0]
+    return tensor
+
+
+def _pair_box_cls(predictions: dict) -> list[tuple[Any, Any]]:
+    """Group outputs into (box, cls) pairs by shared N (= H·W)."""
+    tensors = {str(k): _squeeze_batch(_as_list(v)) for k, v in predictions.items()}
+    boxes: dict[int, Any] = {}
+    classes: dict[int, Any] = {}
+    for tensor in tensors.values():
+        shape = _shape(tensor)
+        if len(shape) != 2:
+            continue
+        n, width = shape
+        if width == 4 * REG_MAX:
+            boxes[n] = tensor
+        elif width > 0 and width != 4 * REG_MAX:
+            classes[n] = tensor
+    pairs: list[tuple[Any, Any]] = []
+    for n, box in boxes.items():
+        cls = classes.get(n)
+        if cls is None:
+            continue
+        pairs.append((box, cls))
+    if not pairs:
+        raise ValueError(
+            "yolo-split-dfl: expected paired box[N,64] + cls[N,C] tensors; "
+            f"got shapes {[(_shape(_squeeze_batch(_as_list(v)))) for v in predictions.values()]}"
+        )
+    # Largest N first (finest stride) — stable, matches Scrypted 1600→400→100.
+    pairs.sort(key=lambda p: _shape(p[0])[0], reverse=True)
+    return pairs
+
+
+def _infer_stride(n: int, input_size: int) -> int:
+    """N = (input_size / stride)² → stride = input_size / sqrt(N)."""
+    side = int(round(math.sqrt(n)))
+    if side * side != n or side <= 0:
+        # Fall back to the canonical 320² strides by matching known Ns.
+        known = {1600: 8, 400: 16, 100: 32, (640 // 8) ** 2: 8}
+        if n in known:
+            return known[n]
+        raise ValueError(f"yolo-split-dfl: cannot infer grid side from N={n}")
+    stride = input_size // side
+    if stride * side != input_size:
+        # Non-divisible — still use the rounded stride from side.
+        stride = max(1, int(round(input_size / side)))
+    return stride
+
+
+def _to_original(
+    x1: float,
+    y1: float,
+    x2: float,
+    y2: float,
+    *,
+    orig_w: int,
+    orig_h: int,
+    scale: float,
+    pad: tuple[int, int],
+    config: dict,
+) -> tuple[float, float, float, float]:
+    mode = config.get("preprocessMode", "letterbox")
+    if mode == "resize":
+        in_w = float(config.get("inputWidth") or config.get("inputSize") or 320)
+        in_h = float(config.get("inputHeight") or config.get("inputSize") or 320)
+        if in_w <= 0 or in_h <= 0:
+            in_w = in_h = 320.0
+        ox1 = x1 * orig_w / in_w
+        oy1 = y1 * orig_h / in_h
+        ox2 = x2 * orig_w / in_w
+        oy2 = y2 * orig_h / in_h
+    else:
+        ox1 = (x1 - pad[0]) / scale
+        oy1 = (y1 - pad[1]) / scale
+        ox2 = (x2 - pad[0]) / scale
+        oy2 = (y2 - pad[1]) / scale
+    return (
+        max(0.0, min(float(orig_w), ox1)),
+        max(0.0, min(float(orig_h), oy1)),
+        max(0.0, min(float(orig_w), ox2)),
+        max(0.0, min(float(orig_h), oy2)),
+    )
+
+
+def postprocess_yolo_split_dfl(
+    predictions: dict,
+    config: dict,
+    orig_w: int,
+    orig_h: int,
+    scale: float,
+    pad: tuple[int, int],
+) -> dict:
+    conf_threshold = float(config.get("confidence", 0))
+    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)
+
+    candidates: list[dict] = []
+    for box_tensor, cls_tensor in _pair_box_cls(predictions):
+        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):
+            # Class score first — skip cold cells before DFL.
+            logits = cls_tensor[i]
+            best_c = 0
+            best_logit = float(logits[0])
+            for c in range(1, num_classes):
+                v = float(logits[c])
+                if v > best_logit:
+                    best_logit = v
+                    best_c = c
+            score = _sigmoid(best_logit)
+            if score < conf_threshold:
+                continue
+
+            dist = box_tensor[i]
+            if len(dist) != 4 * REG_MAX:
+                continue
+            l = _dfl_distance([float(x) for x in dist[0:16]])
+            t = _dfl_distance([float(x) for x in dist[16:32]])
+            r = _dfl_distance([float(x) for x in dist[32:48]])
+            b = _dfl_distance([float(x) for x in dist[48:64]])
+
+            gy, gx = i // grid, i % grid
+            # Ultralytics-style anchor centre at (gx + 0.5, gy + 0.5) * stride;
+            # distances are in cell units → multiply by stride for pixels.
+            cx = (gx + 0.5) * stride
+            cy = (gy + 0.5) * stride
+            x1 = cx - l * stride
+            y1 = cy - t * stride
+            x2 = cx + r * stride
+            y2 = cy + b * stride
+
+            ox1, oy1, ox2, oy2 = _to_original(
+                x1, y1, x2, y2,
+                orig_w=orig_w, orig_h=orig_h, scale=scale, pad=pad, config=config,
+            )
+            if ox2 <= ox1 or oy2 <= oy1:
+                continue
+
+            label = labels[best_c] if best_c < len(labels) else str(best_c)
+            candidates.append(
+                {
+                    "class": label,
+                    "score": round(score, 4),
+                    "bbox": [round(ox1, 1), round(oy1, 1), round(ox2, 1), round(oy2, 1)],
+                    "_xyxy": (ox1, oy1, ox2, oy2),
+                }
+            )
+
+    kept = _nms(candidates, nms_iou)
+    detections = [
+        {"class": d["class"], "score": d["score"], "bbox": d["bbox"]} for d in kept
+    ]
+    return {"kind": "detections", "detections": detections}