@camstack/addon-pipeline 1.2.103 → 1.2.105

package/python/test_inference_pool_reconfigure.py

@@ -0,0 +1,122 @@
+"""The `reconfigure` command retunes a LOADED slot without reloading it.
+
+D214 follow-up. `nmsIouThreshold` was a dead knob end to end; now the operator's
+value reaches `slot.config`, and a CHANGE to it must not cost a session reload —
+`replace` is unload+load (~1.4s on coreml, an OpenVINO recompile) and stalls
+every live camera routed to the pool.
+
+Two properties are load-bearing and pinned here:
+  1. the patch lands on the named index ONLY, leaving the model object and every
+     other slot untouched (the postprocessor re-reads `slot.config` per frame,
+     which is what makes an in-place update take effect);
+  2. a key outside the allow-list is REFUSED. A `path` accepted here would be
+     written into the config while the loaded session kept serving the old
+     model — an undetectable lie. That caller must use `replace`.
+
+Heavy runtime deps are stubbed exactly as the sibling pool tests do, so the
+module imports on a bare interpreter.
+"""
+import sys
+import types
+import unittest
+
+try:  # real numpy when the sandbox has it — a blind stub POISONS the whole
+    import numpy  # noqa: F401  # pytest session for every sibling that needs it
+except ImportError:
+    _np = types.ModuleType("numpy")
+    _np.array = lambda seq, dtype=None: list(seq)  # noqa: E731
+    _np.float32 = "float32"
+    sys.modules["numpy"] = _np
+try:  # real PIL when present, for the same reason
+    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
+
+from inference_pool import (  # noqa: E402
+    RECONFIGURABLE_CONFIG_KEYS,
+    ModelSlot,
+    _handle_command,
+)
+
+
+def _loaded_slot(nms: float = 0.45) -> ModelSlot:
+    slot = ModelSlot()
+    slot.model = object()
+    slot.loaded = True
+    slot.config = {
+        "path": "/models/camstack-yolo26n.onnx",
+        "postprocessor": "yolo",
+        "confidence": 0.05,
+        "nmsIouThreshold": nms,
+    }
+    return slot
+
+
+class ReconfigureCommand(unittest.TestCase):
+    def test_applies_the_patch_to_the_named_slot_only(self) -> None:
+        models = [_loaded_slot(0.45), _loaded_slot(0.45)]
+        model_object = models[0].model
+
+        resp = _handle_command(
+            models, {"cmd": "reconfigure", "index": 0, "config": {"nmsIouThreshold": 0.7}}
+        )
+
+        self.assertEqual(resp["status"], "ok")
+        self.assertEqual(models[0].config["nmsIouThreshold"], 0.7)
+        # The session is NOT re-instantiated: same object, still loaded.
+        self.assertIs(models[0].model, model_object)
+        self.assertTrue(models[0].loaded)
+        # Every other slot is untouched — the whole point of a per-pair retune.
+        self.assertEqual(models[1].config["nmsIouThreshold"], 0.45)
+
+    def test_leaves_the_rest_of_the_config_alone(self) -> None:
+        models = [_loaded_slot(0.45)]
+        _handle_command(
+            models, {"cmd": "reconfigure", "index": 0, "config": {"nmsIouThreshold": 0.2}}
+        )
+        self.assertEqual(models[0].config["path"], "/models/camstack-yolo26n.onnx")
+        self.assertEqual(models[0].config["postprocessor"], "yolo")
+        self.assertEqual(models[0].config["confidence"], 0.05)
+
+    def test_refuses_a_key_that_needs_a_reload(self) -> None:
+        models = [_loaded_slot(0.45)]
+        resp = _handle_command(
+            models,
+            {"cmd": "reconfigure", "index": 0, "config": {"path": "/models/other.onnx"}},
+        )
+        self.assertEqual(resp["status"], "error")
+        self.assertIn("path", resp["error"])
+        # And it did NOT half-apply.
+        self.assertEqual(models[0].config["path"], "/models/camstack-yolo26n.onnx")
+
+    def test_refuses_an_unloaded_slot_instead_of_writing_a_ghost_config(self) -> None:
+        models = [ModelSlot()]
+        resp = _handle_command(
+            models, {"cmd": "reconfigure", "index": 0, "config": {"nmsIouThreshold": 0.7}}
+        )
+        self.assertEqual(resp["status"], "error")
+        self.assertIn("not loaded", resp["error"])
+
+    def test_refuses_an_index_past_the_end(self) -> None:
+        models = [_loaded_slot()]
+        resp = _handle_command(
+            models, {"cmd": "reconfigure", "index": 9, "config": {"nmsIouThreshold": 0.7}}
+        )
+        self.assertEqual(resp["status"], "error")
+        # A `load`/`replace` grows the slot list; `reconfigure` must not — it
+        # would leave a config with no model behind it.
+        self.assertEqual(len(models), 1)
+
+    def test_the_allow_list_mirrors_the_typescript_PoolDecodeSettings(self) -> None:
+        # Adding a key on one side only reintroduces the D214 dead-knob class:
+        # TS would record the value as applied while Python refused it (or
+        # accepted a key the decode never reads).
+        self.assertEqual(RECONFIGURABLE_CONFIG_KEYS, frozenset({"nmsIouThreshold"}))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/test_inference_pool_static_batch.py

@@ -0,0 +1,426 @@
+"""Batch capability is a HARDWARE FACT, decided at load — never a setting.
+
+Two layers are covered:
+
+  1. The PURE derivation — `_ov_static_batch_required` (engine+device -> may the
+     graph keep a dynamic batch axis?) and `_static_batch_plan` (which inputs
+     have a pinnable dynamic BATCH axis, and which carry a dynamic axis that is
+     NOT the batch and therefore cannot be pinned). No OpenVINO import: these
+     run in a bare sandbox.
+
+  2. The REAL reshape — when OpenVINO is installed the last class builds a tiny
+     ONNX graph with a dynamic first dimension, reads it as an OV model and runs
+     `_pin_batch_for_device` against an NPU-shaped target and a CPU one. NPU
+     must come back STATIC 1 (this is the compile that hung the hub live on
+     2026-08-20: "Got negative shape dim bound: '-1'", then a load that never
+     completed), CPU must come back UNTOUCHED and still dynamic.
+
+Run: /tmp/conv-venv/bin/python -m pytest test_inference_pool_static_batch.py -v
+     (or `python3 -m unittest test_inference_pool_static_batch -v` — the pure
+     classes run without OpenVINO; the OV class self-skips.)
+"""
+from __future__ import annotations
+
+import sys
+import types
+import unittest
+from typing import Any
+
+# ---------------------------------------------------------------------------
+# Stub the heavy third-party imports ONLY when they are genuinely absent, and
+# BEFORE importing inference_pool. A blind stub would shadow the REAL numpy the
+# OpenVINO class below needs, so every stub is an ImportError fallback.
+# ---------------------------------------------------------------------------
+
+try:  # pragma: no cover - environment-dependent
+    import numpy  # noqa: F401
+except ImportError:  # pragma: no cover
+    _np = types.ModuleType("numpy")
+    _np.array = lambda seq, dtype=None: list(seq)  # noqa: E731
+    _np.float32 = "float32"
+    sys.modules["numpy"] = _np
+
+try:  # pragma: no cover - environment-dependent
+    import PIL.Image  # noqa: F401
+except ImportError:  # pragma: no cover
+    _pil = types.ModuleType("PIL")
+    _pil_image = types.ModuleType("PIL.Image")
+    _pil.Image = _pil_image
+    sys.modules["PIL"] = _pil
+    sys.modules["PIL.Image"] = _pil_image
+
+try:  # pragma: no cover - environment-dependent
+    import postprocessors  # noqa: F401
+except ImportError:  # pragma: no cover
+    _pp = types.ModuleType("postprocessors")
+    _pp.POSTPROCESSORS = {}
+    sys.modules["postprocessors"] = _pp
+
+from inference_pool import (  # noqa: E402
+    STATIC_BATCH_PIN,
+    _pin_batch_for_device,
+    _static_batch_plan,
+    _static_batch_required,
+)
+
+
+class StaticBatchRequiredTest(unittest.TestCase):
+    """The rule itself: which (engine, device) pairs refuse a dynamic shape.
+
+    ONE authority for every engine. Only the Intel NPU refuses, and it is not a
+    preference — the Level-Zero compiler rejects the graph outright, and because
+    a pool load failure is a retry loop rather than an error the caller sees,
+    getting this wrong looks like a busy pool, not a broken one.
+    """
+
+    def test_openvino_npu_requires_static_batch(self) -> None:
+        self.assertTrue(_static_batch_required("openvino", "NPU"))
+
+    def test_npu_with_index_suffix_requires_static_batch(self) -> None:
+        # OpenVINO enumerates multiple units as NPU.0 / NPU.1.
+        self.assertTrue(_static_batch_required("openvino", "NPU.0"))
+
+    def test_lowercase_and_padded_pin_is_still_the_npu(self) -> None:
+        self.assertTrue(_static_batch_required("openvino", " npu "))
+
+    def test_openvino_cpu_keeps_dynamic(self) -> None:
+        self.assertFalse(_static_batch_required("openvino", "CPU"))
+
+    def test_openvino_gpu_keeps_dynamic(self) -> None:
+        self.assertFalse(_static_batch_required("openvino", "GPU"))
+
+    def test_openvino_gpu_with_index_suffix_keeps_dynamic(self) -> None:
+        self.assertFalse(_static_batch_required("openvino", "GPU.1"))
+
+    def test_empty_device_keeps_dynamic(self) -> None:
+        # A missing device name must never silently pin a graph.
+        self.assertFalse(_static_batch_required("openvino", ""))
+
+    def test_onnxruntime_keeps_dynamic(self) -> None:
+        self.assertFalse(_static_batch_required("onnxruntime", "cuda"))
+        self.assertFalse(_static_batch_required("onnxruntime", "cpu"))
+
+    def test_coreml_keeps_dynamic(self) -> None:
+        # A RangeDim export is what the batched ANE dispatch path reads; the
+        # loader must never pin it away.
+        self.assertFalse(_static_batch_required("coreml", "ane"))
+        self.assertFalse(_static_batch_required("coreml", "all"))
+
+    def test_edgetpu_keeps_dynamic(self) -> None:
+        # A tflite/edgetpu graph is static by construction — nothing to pin.
+        self.assertFalse(_static_batch_required("edgetpu", "usb:0"))
+
+    def test_an_npu_named_device_on_another_engine_is_not_the_intel_npu(self) -> None:
+        # The rule is a PAIR. `coreml`'s Neural Engine is not Level Zero.
+        self.assertFalse(_static_batch_required("coreml", "npu"))
+
+
+class StaticBatchPlanTest(unittest.TestCase):
+    """Which inputs get pinned, and which are honestly reported as unpinnable."""
+
+    def test_dynamic_batch_is_pinned_to_one(self) -> None:
+        plan, unpinnable = _static_batch_plan([[None, 64, 128, 3]])
+        self.assertEqual(plan, {0: [STATIC_BATCH_PIN, 64, 128, 3]})
+        self.assertEqual(unpinnable, [])
+
+    def test_already_static_graph_needs_no_reshape(self) -> None:
+        plan, unpinnable = _static_batch_plan([[1, 3, 640, 640]])
+        self.assertEqual(plan, {})
+        self.assertEqual(unpinnable, [])
+
+    def test_static_batch_greater_than_one_is_left_alone(self) -> None:
+        # An export that deliberately declares batch 4 is a static shape; the
+        # rule pins DYNAMIC axes, it does not renegotiate static ones.
+        plan, unpinnable = _static_batch_plan([[4, 3, 640, 640]])
+        self.assertEqual(plan, {})
+        self.assertEqual(unpinnable, [])
+
+    def test_dynamic_spatial_axis_cannot_be_pinned(self) -> None:
+        # A dynamic H/W has no value we are allowed to invent — report it so the
+        # compile failure below is explained rather than silent.
+        plan, unpinnable = _static_batch_plan([[None, 3, None, 640]])
+        self.assertEqual(plan, {})
+        self.assertEqual(unpinnable, [0])
+
+    def test_multi_input_pins_only_the_dynamic_ones(self) -> None:
+        plan, unpinnable = _static_batch_plan([
+            [1, 3, 640, 640],
+            [None, 3, 112, 112],
+        ])
+        self.assertEqual(plan, {1: [STATIC_BATCH_PIN, 3, 112, 112]})
+        self.assertEqual(unpinnable, [])
+
+    def test_unreadable_shape_is_not_guessed(self) -> None:
+        plan, unpinnable = _static_batch_plan([None])
+        self.assertEqual(plan, {})
+        self.assertEqual(unpinnable, [0])
+
+    def test_rank_one_dynamic_is_pinnable(self) -> None:
+        plan, unpinnable = _static_batch_plan([[None]])
+        self.assertEqual(plan, {0: [STATIC_BATCH_PIN]})
+        self.assertEqual(unpinnable, [])
+
+
+def _dynamic_batch_ov_model(core, tmpdir: str):
+    """Build the smallest ONNX with a DYNAMIC first dim and read it as an OV
+    model. Mirrors what `ov.convert_model` produces from every dynamic-batch
+    export in this repo (`scripts/build-camstack-models.py`, and the
+    model-studio convert path)."""
+    import os
+
+    import onnx
+    from onnx import TensorProto, helper
+
+    inp = helper.make_tensor_value_info(
+        "input", TensorProto.FLOAT, ["batch", 4],
+    )
+    out = helper.make_tensor_value_info(
+        "output", TensorProto.FLOAT, ["batch", 4],
+    )
+    node = helper.make_node("Relu", ["input"], ["output"])
+    graph = helper.make_graph([node], "dyn", [inp], [out])
+    model = helper.make_model(
+        graph, opset_imports=[helper.make_operatorsetid("", 17)],
+    )
+    onnx.checker.check_model(model)
+    path = os.path.join(tmpdir, "dyn.onnx")
+    onnx.save(model, path)
+    return core.read_model(path), path
+
+
+class OpenVinoReshapeTest(unittest.TestCase):
+    """The real thing: a dynamic-batch IR compiled for an NPU target.
+
+    This is the case that hung the hub. Without the load-time reshape the graph
+    reaches the Level-Zero compiler with a `-1` dim; with it, the model handed to
+    `compile_model` is static and the compile is a normal one.
+    """
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        try:
+            import onnx  # noqa: F401
+            import openvino  # noqa: F401
+        except ImportError:  # pragma: no cover - sandbox without the runtime
+            raise unittest.SkipTest("openvino/onnx not installed")
+
+    def test_dynamic_batch_is_reshaped_static_for_the_npu(self) -> None:
+        import tempfile
+
+        import openvino as ov
+
+        core = ov.Core()
+        with tempfile.TemporaryDirectory() as tmp:
+            model, path = _dynamic_batch_ov_model(core, tmp)
+            self.assertTrue(
+                model.input(0).get_partial_shape()[0].is_dynamic,
+                "fixture must start dynamic or the test proves nothing",
+            )
+            pinned = _pin_batch_for_device(core, model, path, "NPU")
+            shape = pinned.input(0).get_partial_shape()
+            self.assertTrue(shape[0].is_static)
+            self.assertEqual(shape[0].get_length(), STATIC_BATCH_PIN)
+            # Shape inference must have carried the pin to the OUTPUT too — the
+            # plate model carried the `-1` on both ends.
+            out_shape = pinned.output(0).get_partial_shape()
+            self.assertTrue(out_shape[0].is_static)
+            self.assertEqual(out_shape[0].get_length(), STATIC_BATCH_PIN)
+
+    def test_the_source_model_object_is_never_mutated(self) -> None:
+        # `Model.reshape` mutates in place, and on the PrePostProcessor path the
+        # compile loop REUSES the same object for the next candidate. If the pin
+        # leaked, a GPU fallback after a failed NPU attempt would silently
+        # compile the pinned graph.
+        import tempfile
+
+        import openvino as ov
+
+        core = ov.Core()
+        with tempfile.TemporaryDirectory() as tmp:
+            model, path = _dynamic_batch_ov_model(core, tmp)
+            pinned = _pin_batch_for_device(core, model, path, "NPU")
+            self.assertIsNot(pinned, model)
+            self.assertTrue(
+                model.input(0).get_partial_shape()[0].is_dynamic,
+                "the source the caller holds must still be dynamic",
+            )
+
+    def test_dynamic_batch_survives_on_cpu(self) -> None:
+        import tempfile
+
+        import openvino as ov
+
+        core = ov.Core()
+        with tempfile.TemporaryDirectory() as tmp:
+            model, path = _dynamic_batch_ov_model(core, tmp)
+            same = _pin_batch_for_device(core, model, path, "CPU")
+            self.assertIs(same, model, "CPU must get the source object untouched")
+            self.assertTrue(same.input(0).get_partial_shape()[0].is_dynamic)
+
+    def test_dynamic_batch_survives_on_gpu(self) -> None:
+        import tempfile
+
+        import openvino as ov
+
+        core = ov.Core()
+        with tempfile.TemporaryDirectory() as tmp:
+            model, path = _dynamic_batch_ov_model(core, tmp)
+            same = _pin_batch_for_device(core, model, path, "GPU")
+            self.assertTrue(same.input(0).get_partial_shape()[0].is_dynamic)
+
+    def test_a_path_source_is_read_and_pinned_for_the_npu(self) -> None:
+        # The non-PPP load path hands `compile_model` the IR PATH, not a model
+        # object. The pin has to work from either.
+        import tempfile
+
+        import openvino as ov
+
+        core = ov.Core()
+        with tempfile.TemporaryDirectory() as tmp:
+            _model, path = _dynamic_batch_ov_model(core, tmp)
+            pinned = _pin_batch_for_device(core, path, path, "NPU")
+            self.assertNotIsInstance(pinned, str)
+            shape = pinned.input(0).get_partial_shape()
+            self.assertTrue(shape[0].is_static)
+            self.assertEqual(shape[0].get_length(), STATIC_BATCH_PIN)
+
+    def test_a_path_source_is_left_a_path_on_cpu(self) -> None:
+        # No reshape needed => no wasted read_model; compile still takes the path.
+        import tempfile
+
+        import openvino as ov
+
+        core = ov.Core()
+        with tempfile.TemporaryDirectory() as tmp:
+            _model, path = _dynamic_batch_ov_model(core, tmp)
+            self.assertEqual(_pin_batch_for_device(core, path, path, "CPU"), path)
+
+    def test_an_already_static_graph_is_not_re_read_for_the_npu(self) -> None:
+        import os
+        import tempfile
+
+        import onnx
+        import openvino as ov
+        from onnx import TensorProto, helper
+
+        core = ov.Core()
+        with tempfile.TemporaryDirectory() as tmp:
+            inp = helper.make_tensor_value_info("input", TensorProto.FLOAT, [1, 4])
+            out = helper.make_tensor_value_info("output", TensorProto.FLOAT, [1, 4])
+            graph = helper.make_graph(
+                [helper.make_node("Relu", ["input"], ["output"])],
+                "static", [inp], [out],
+            )
+            model = helper.make_model(
+                graph, opset_imports=[helper.make_operatorsetid("", 17)],
+            )
+            path = os.path.join(tmp, "static.onnx")
+            onnx.save(model, path)
+            ov_model = core.read_model(path)
+            self.assertIs(_pin_batch_for_device(core, ov_model, path, "NPU"), ov_model)
+
+    def test_the_pinned_model_actually_compiles_on_cpu(self) -> None:
+        # End of the chain: a reshaped model is still a compilable model. (The
+        # NPU itself is not present on a dev machine — CPU proves the graph
+        # survived the reshape, the shape assertions above prove it is static.)
+        import tempfile
+
+        import numpy as np
+        import openvino as ov
+
+        core = ov.Core()
+        with tempfile.TemporaryDirectory() as tmp:
+            model, path = _dynamic_batch_ov_model(core, tmp)
+            pinned = _pin_batch_for_device(core, model, path, "NPU")
+            compiled = core.compile_model(pinned, device_name="CPU")
+            result = compiled(np.zeros((1, 4), dtype=np.float32))
+            self.assertEqual(list(result[compiled.output(0)].shape), [1, 4])
+
+
+class _RecordingCore:
+    """A real `ov.Core` with `compile_model` intercepted: it records EXACTLY what
+    the loader handed the compiler, then compiles it for CPU so the rest of the
+    load path (outputs, properties, infer requests) runs for real.
+
+    This is the fake that cannot lie in the dangerous direction — it supplies
+    nothing, it only observes production's own argument.
+    """
+
+    def __init__(self, real: Any) -> None:  # noqa: ANN401 - test double
+        self._real = real
+        self.compiled: list = []
+
+    def read_model(self, path: str) -> Any:  # noqa: ANN401 - test double
+        return self._real.read_model(path)
+
+    def compile_model(self, source: Any, device_name: str, config: Any = None) -> Any:  # noqa: ANN401
+        self.compiled.append((source, device_name))
+        return self._real.compile_model(source, device_name="CPU")
+
+
+class LoadPathAppliesTheRuleTest(unittest.TestCase):
+    """The derivation has to happen AT THE LOAD, not merely be available.
+
+    Drives `_load_model`'s OpenVINO branch with an operator-pinned NPU device
+    and asserts the object that reached `compile_model` was static. Remove the
+    `_pin_batch_for_device` call from the compile loop and this goes red —
+    the helper tests above would stay green.
+    """
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        try:
+            import onnx  # noqa: F401
+            import openvino  # noqa: F401
+        except ImportError:  # pragma: no cover - sandbox without the runtime
+            raise unittest.SkipTest("openvino/onnx not installed")
+
+    def _load_with_pinned_device(self, device: str) -> tuple:
+        import tempfile
+
+        import openvino as ov
+
+        import inference_pool as ip
+
+        core = ov.Core()
+        saved = (ip._runtime, ip._runtime_lib, ip._OV_PPP_ENABLED, ip._OV_ASYNC_ENABLED)
+        with tempfile.TemporaryDirectory() as tmp:
+            _model, path = _dynamic_batch_ov_model(core, tmp)
+            recording = _RecordingCore(core)
+            ip._runtime = "openvino"
+            ip._runtime_lib = recording
+            # PPP folds a uint8 NHWC preprocessor into image graphs; this 2-D
+            # fixture is not one, and disabling it keeps the test on the plain
+            # path where `compile_source` is the PATH — the harder case.
+            ip._OV_PPP_ENABLED = False
+            ip._OV_ASYNC_ENABLED = False
+            try:
+                slot = ip.ModelSlot()
+                ip._load_model(slot, {"path": path, "device": device})
+            finally:
+                (ip._runtime, ip._runtime_lib,
+                 ip._OV_PPP_ENABLED, ip._OV_ASYNC_ENABLED) = saved
+            self.assertTrue(slot.loaded)
+            self.assertEqual(len(recording.compiled), 1)
+            return recording.compiled[0]
+
+    def test_npu_pin_reaches_the_compiler_static(self) -> None:
+        source, device = self._load_with_pinned_device("NPU")
+        self.assertEqual(device, "NPU")
+        self.assertNotIsInstance(
+            source, str, "the NPU must be handed a reshaped model, not the raw IR path",
+        )
+        shape = source.input(0).get_partial_shape()
+        self.assertTrue(shape[0].is_static)
+        self.assertEqual(shape[0].get_length(), STATIC_BATCH_PIN)
+
+    def test_gpu_pin_reaches_the_compiler_untouched(self) -> None:
+        source, device = self._load_with_pinned_device("GPU")
+        self.assertEqual(device, "GPU")
+        self.assertIsInstance(
+            source, str, "a target that accepts dynamic dims gets the path as before",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

package/dist/remote-restream-Ci7RXNGb.mjs

@@ -1,66 +0,0 @@
-/**
-* Path suffix for the audio-free variant dialed by a DETECTION decode session.
-* Muted in every respect (no audio, still `isMuted()`), plus exempt from the
-* live-edge join withhold.
-*/
-var DETECTION_MUTED_PATH_SUFFIX = "/muted-detection";
-/**
-* Split a restream request path (already stripped of `rtsp://host:port/` and of
-* any `/trackID=N` control suffix) into its token, mute bit and intent.
-*/
-function parseRestreamPath(streamPath) {
-	if (streamPath.endsWith("/muted-detection")) return {
-		lookupPath: streamPath.slice(0, -16),
-		muted: true,
-		intent: "detection"
-	};
-	if (streamPath.endsWith("/muted")) return {
-		lookupPath: streamPath.slice(0, -6),
-		muted: true,
-		intent: null
-	};
-	return {
-		lookupPath: streamPath,
-		muted: false,
-		intent: null
-	};
-}
-/**
-* Rewrite an acquired restream URL to declare the detection intent.
-*
-* Only a MUTED url is rewritten. `resolveSourceUrl` falls back to the
-* audio-bearing url when the broker has no muted variant; that session is not
-* muted, the live-edge withhold never applied to it, and appending the suffix
-* would only break the token lookup. Idempotent.
-*/
-function withDetectionIntent(restreamUrl) {
-	if (restreamUrl.endsWith("/muted-detection")) return restreamUrl;
-	if (!restreamUrl.endsWith("/muted")) return restreamUrl;
-	return `${restreamUrl.slice(0, -6)}${DETECTION_MUTED_PATH_SUFFIX}`;
-}
-//#endregion
-//#region src/pipeline-runner/remote-restream.ts
-/**
-* Runner-side mode selection (pure): whether an attach payload routes this
-* camera through the remote-source leg. Absent `frameSource` (a pre-P2c
-* payload) and `local-broker` both take the co-located broker path.
-*/
-function isRemoteRestream(frameSource) {
-	return frameSource !== void 0 && frameSource.kind === "remote-restream";
-}
-/**
-* Resolve WHICH broker profile a camStream id feeds for a device (pure).
-*
-* `getStreamWithCodec` targets a PROFILE (its assigned camStream), while the
-* runner is dispatched with camStream ids (`motionStreamId` /
-* `detectionStreamId`). The broker's profile slots carry the mapping
-* (`sourceCamStreamId`); a stream no slot feeds returns `null` — the acquire
-* fails fast and the caller's backoff retries (the assignment may still be
-* propagating).
-*/
-function profileForStreamId(slots, deviceId, streamId) {
-	for (const slot of slots) if (slot.deviceId === deviceId && slot.sourceCamStreamId === streamId) return slot.profile;
-	return null;
-}
-//#endregion
-export { withDetectionIntent as i, profileForStreamId as n, parseRestreamPath as r, isRemoteRestream as t };