@camstack/addon-pipeline 1.2.349 → 1.2.351

package/dist/stream-broker/{_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-CFZDNGBf.mjs → _virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-BgC3mSLA.mjs}

@@ -18,7 +18,7 @@ var e = {
 	},
 	"@camstack/types": {
 		name: "@camstack/types",
-		version: "1.2.337",
+		version: "1.2.339",
 		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.258",
+		version: "1.2.259",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_stream_broker_widgets",

package/dist/stream-broker/demux-worker-child.js

@@ -1,4 +1,4 @@
-const require_segment_demux_js = require("../segment-demux-js-BEaJw3G9.js");
+const require_segment_demux_js = require("../segment-demux-js-B2IxTWms.js");
 let node_worker_threads = require("node:worker_threads");
 //#region src/stream-broker/recorded/demux-worker-child.ts
 /**

package/dist/stream-broker/demux-worker-child.mjs

@@ -1,4 +1,4 @@
-import { t as demuxSegmentFullJs } from "../segment-demux-js-CjTXPNsG.mjs";
+import { t as demuxSegmentFullJs } from "../segment-demux-js-7l4LsdU4.mjs";
 import { parentPort } from "node:worker_threads";
 //#region src/stream-broker/recorded/demux-worker-child.ts
 /**

package/dist/stream-broker/{hostInit-Bx_U_Tc7.mjs → hostInit-DfOhCBj-.mjs}

@@ -36,7 +36,7 @@ async function r() {
 				}
 			},
 			"@camstack/types": {
-				version: "1.2.337",
+				version: "1.2.339",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,
@@ -81,7 +81,7 @@ async function r() {
 				}
 			},
 			"@camstack/ui-library": {
-				version: "1.2.258",
+				version: "1.2.259",
 				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-BrHqpGoN.js");
-const require_node = require("../node-CJ1zilVO.js");
+const require_dist = require("../dist-C2jSMJo_.js");
+const require_node = require("../node-B7ZinEw5.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-BEaJw3G9.js");
+const require_segment_demux_js = require("../segment-demux-js-B2IxTWms.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 { $n as discriminatedUnion, An as DeviceFeature, At as gifFromMp4Args, Cn as AUDIO_PRESETS, D as G711_SCALE_CORRECTION_DB, Dt as ffmpegRate, En as buildFfmpegArgs, Fn as CAM_PROFILE_ORDER, Gn as makeSourceBrokerId, Ht as memoizePinnedFfmpeg, In as CamProfileSchema, It as loadContributionCapability, K as RingBuffer, Kn as nodePin, Lt as logChannelsCapability, Mn as errMsg, Nn as BOOT_RECOVERY_BACKOFF_MS, On as invocationFromEncodeProfile, Pn as BaseAddon, Qn as boolean, R as RATE_CONTROL_RELAXED, Rn as createEvent, Sn as webrtcSessionCapability, Un as isEvent, Vn as expandAudioChunkToF32le, Wn as makeProfileBrokerId, X as addonWidgetsSourceCapability, Xn as _enum, Zn as array, ar as record, at as cameraStreamsCapability, bt as egressTransportFromRequest, c as CLIP_STILL_REASON_CODE_HEADER, cr as EventCategory, dt as createLogChannelsProvider, en as rankStreams, ft as declareLogChannel, jn as DeviceType, kn as isSoftwareDecode, kt as gifDeriveSpeed, mt as deriveBatteryPresence, nr as number, nt as batteryCapability, o as BatteryStatusSchema, or as string, qn as parseProfileBrokerId, rr as object, s as CLIP_BROKER_PACED_RATES, sn as resolveEgressDecodeHwAccel, sr as union, st as clipExportFailureOf, tr as literal, ut as createHwAccelCache, vn as streamBrokerCapability, w as EncodeProfileSchema, yt as egressTranscodeSharingKey, z as RATE_CONTROL_TIGHT, zt as maskUrlCredentials } from "../dist-Cr4QsawE.mjs";
-import { i as NO_COST_CLAIM, n as Fmp4FragmentChild, o as probeFfmpegBinary, r as Fmp4FragmentPlane, t as ChildCostRegistry } from "../node-Dym0f_3g.mjs";
+import { $n as discriminatedUnion, An as DeviceFeature, At as gifFromMp4Args, Cn as AUDIO_PRESETS, D as G711_SCALE_CORRECTION_DB, Dt as ffmpegRate, En as buildFfmpegArgs, Fn as CAM_PROFILE_ORDER, Gn as makeSourceBrokerId, Ht as memoizePinnedFfmpeg, In as CamProfileSchema, It as loadContributionCapability, K as RingBuffer, Kn as nodePin, Lt as logChannelsCapability, Mn as errMsg, Nn as BOOT_RECOVERY_BACKOFF_MS, On as invocationFromEncodeProfile, Pn as BaseAddon, Qn as boolean, R as RATE_CONTROL_RELAXED, Rn as createEvent, Sn as webrtcSessionCapability, Un as isEvent, Vn as expandAudioChunkToF32le, Wn as makeProfileBrokerId, X as addonWidgetsSourceCapability, Xn as _enum, Zn as array, ar as record, at as cameraStreamsCapability, bt as egressTransportFromRequest, c as CLIP_STILL_REASON_CODE_HEADER, cr as EventCategory, dt as createLogChannelsProvider, en as rankStreams, ft as declareLogChannel, jn as DeviceType, kn as isSoftwareDecode, kt as gifDeriveSpeed, mt as deriveBatteryPresence, nr as number, nt as batteryCapability, o as BatteryStatusSchema, or as string, qn as parseProfileBrokerId, rr as object, s as CLIP_BROKER_PACED_RATES, sn as resolveEgressDecodeHwAccel, sr as union, st as clipExportFailureOf, tr as literal, ut as createHwAccelCache, vn as streamBrokerCapability, w as EncodeProfileSchema, yt as egressTranscodeSharingKey, z as RATE_CONTROL_TIGHT, zt as maskUrlCredentials } from "../dist-DFCl7PZV.mjs";
+import { i as NO_COST_CLAIM, n as Fmp4FragmentChild, o as probeFfmpegBinary, r as Fmp4FragmentPlane, t as ChildCostRegistry } from "../node-C12l0K5V.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-CjTXPNsG.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-7l4LsdU4.mjs";
 import { createRequire } from "node:module";
 import * as os$1 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-CFZDNGBf.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-BgC3mSLA.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-pipeline",
-  "version": "1.2.349",
+  "version": "1.2.351",
   "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

@@ -468,6 +468,8 @@ def _resolve_onnx_providers(
     Deliberate adaptations for camstack:
       - an operator device pin is honored: "cuda"/"coreml" put that EP first
         (CPU still last as fallback); "cpu" compiles CPU only.
+      - "webgpu" is NOT handled here — it uses an isolated child process
+        (`WebGpuIsolatedSession` / webgpu_isolated.py; D823).
       - hardware entries not present in `available`
         (ort.get_available_providers()) are dropped — camstack ships the
         plain `onnxruntime` wheel on most nodes, and requesting an EP the
@@ -481,8 +483,9 @@ def _resolve_onnx_providers(
         ordered.append((ONNX_CUDA_EP, {"device_id": cuda_device_id}))
     elif dev == "coreml":
         ordered.append(ONNX_COREML_EP)
-    elif dev == "cpu":
-        pass  # explicit CPU pin — no hardware EPs
+    elif dev in ("cpu", "webgpu"):
+        # webgpu uses the plugin path; if we fall through here it must be CPU only.
+        pass
     else:
         # AUTO/default — platform-driven ordering.
         if plat == "darwin":
@@ -497,6 +500,12 @@ def _resolve_onnx_providers(
     return providers
 
 
+# WebGPU: one ORT session per OS process (Dawn/Vulkan SIGSEGVs on a second
+# session in-process — amd-proxmox 2026-10-10). Implementation lives in
+# webgpu_isolated.py; the pool parent never holds a WebGPU session itself.
+from webgpu_isolated import WebGpuIsolatedSession  # noqa: E402
+
+
 # ---------------------------------------------------------------------------
 # CoreML persistent compiled-model cache
 # ---------------------------------------------------------------------------
@@ -1328,51 +1337,75 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
     elif _runtime == "onnxruntime":
         ort = _runtime_lib
         ort_device = str(config.get("device", "") or "")
-        # Ordered providers — hardware EP first, CPU LAST as
-        # fallback (see _resolve_onnx_providers): a "cuda"/"coreml" pin puts
-        # that EP first, a "cpu" pin compiles CPU only, and the AUTO/default
-        # case derives the hardware EP from the platform.
-        try:
-            available_eps = list(ort.get_available_providers())
-        except Exception:
-            available_eps = [ONNX_CPU_EP]
-        providers = _resolve_onnx_providers(
-            ort_device, sys.platform, platform.machine(), available_eps,
-        )
-        session = ort.InferenceSession(path, providers=providers)
-        # Report the EP that ACTUALLY initialized (CPU stripped from the log)
-        # so a silent CPU fallback is visible.
-        _active_eps = [p for p in session.get_providers() if p != ONNX_CPU_EP]
-        _requested = [p[0] if isinstance(p, tuple) else p for p in providers]
-        sys.stderr.write(
-            f"ONNX: execution provider {', '.join(_active_eps) or ONNX_CPU_EP} "
-            f"(device={ort_device or 'auto'}, requested={_requested}, "
-            f"available={available_eps})\n"
-        )
-        sys.stderr.flush()
-        output_names = [o.name for o in session.get_outputs()]
-        slot.config["_input_name"] = session.get_inputs()[0].name
-        # Declared input layout (ArcFace/CLIP are NHWC) → correct preprocess.
-        try:
-            slot.config["_input_shape"] = session.get_inputs()[0].shape
-        except Exception:
-            pass
-        # Declared input DTYPE. super-gradients / Frigate YOLO-NAS exports bake
-        # their preprocessing into the graph and take `tensor(uint8)` — the
-        # preprocess must feed raw uint8 pixels, not the float32 [0,1] tensor
-        # (a hard onnxruntime type error otherwise).
-        try:
-            if session.get_inputs()[0].type == "tensor(uint8)":
-                slot.config["_input_dtype"] = "uint8"
-        except Exception:
-            pass
+        # WebGPU uses the plugin-EP SessionOptions path (ORT ≥1.24); everything
+        # else uses the classic providers= list (see _resolve_onnx_providers).
+        if ort_device.strip().lower() == "webgpu":
+            # Isolated child — never create a WebGPU InferenceSession in this
+            # process (second in-process session SIGSEGVs the pool worker).
+            isolated = WebGpuIsolatedSession.open(path)
+            active_list = isolated.providers
+            _active_eps = [p for p in active_list if p != ONNX_CPU_EP]
+            sys.stderr.write(
+                f"ONNX: execution provider {', '.join(_active_eps) or ONNX_CPU_EP} "
+                f"(device=webgpu, isolated)\n"
+            )
+            sys.stderr.flush()
+            slot.config["_input_name"] = isolated.input_name
+            try:
+                slot.config["_input_shape"] = isolated.input_shape
+            except Exception:
+                pass
+            try:
+                if isolated.input_type == "tensor(uint8)":
+                    slot.config["_input_dtype"] = "uint8"
+            except Exception:
+                pass
 
-        def predict(inp_dict: dict) -> dict:
-            outputs = session.run(output_names, inp_dict)
-            return {name: out for name, out in zip(output_names, outputs)}
+            def predict(inp_dict: dict, _iso=isolated) -> dict:
+                return _iso.run(inp_dict)
 
-        slot.model = session
-        slot.predict_fn = predict
+            slot.model = isolated
+            slot.predict_fn = predict
+        else:
+            try:
+                available_eps = list(ort.get_available_providers())
+            except Exception:
+                available_eps = [ONNX_CPU_EP]
+            providers = _resolve_onnx_providers(
+                ort_device, sys.platform, platform.machine(), available_eps,
+            )
+            session = ort.InferenceSession(path, providers=providers)
+            _active_eps = [p for p in session.get_providers() if p != ONNX_CPU_EP]
+            _requested = [p[0] if isinstance(p, tuple) else p for p in providers]
+            sys.stderr.write(
+                f"ONNX: execution provider {', '.join(_active_eps) or ONNX_CPU_EP} "
+                f"(device={ort_device or 'auto'}, requested={_requested}, "
+                f"available={available_eps})\n"
+            )
+            sys.stderr.flush()
+            output_names = [o.name for o in session.get_outputs()]
+            slot.config["_input_name"] = session.get_inputs()[0].name
+            # Declared input layout (ArcFace/CLIP are NHWC) → correct preprocess.
+            try:
+                slot.config["_input_shape"] = session.get_inputs()[0].shape
+            except Exception:
+                pass
+            # Declared input DTYPE. super-gradients / Frigate YOLO-NAS exports bake
+            # their preprocessing into the graph and take `tensor(uint8)` — the
+            # preprocess must feed raw uint8 pixels, not the float32 [0,1] tensor
+            # (a hard onnxruntime type error otherwise).
+            try:
+                if session.get_inputs()[0].type == "tensor(uint8)":
+                    slot.config["_input_dtype"] = "uint8"
+            except Exception:
+                pass
+
+            def predict(inp_dict: dict) -> dict:
+                outputs = session.run(output_names, inp_dict)
+                return {name: out for name, out in zip(output_names, outputs)}
+
+            slot.model = session
+            slot.predict_fn = predict
 
     elif _runtime == "edgetpu":
         Interpreter = _runtime_lib["Interpreter"]
@@ -1445,6 +1478,15 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
 
 
 def _unload_model(slot: ModelSlot) -> None:
+    model = slot.model
+    # WebGpuIsolatedSession (and any future handle) exposes close().
+    close = getattr(model, "close", None)
+    if callable(close):
+        try:
+            close()
+        except Exception as err:
+            sys.stderr.write(f"model close failed: {err}\n")
+            sys.stderr.flush()
     slot.model = None
     slot.predict_fn = None
     slot.input_names = frozenset()

package/python/requirements-webgpu.txt

@@ -0,0 +1,7 @@
+# ONNX Runtime WebGPU plugin EP — AMD iGPU (RADV) and other Vulkan adapters.
+# Requires a compatible core ORT (plugin refuses older builds at register time).
+# Installed lazily when the node offers `onnx:webgpu` (see runtime-packages /
+# shouldInstallWebgpu). Does NOT replace requirements-onnxruntime.txt for the
+# CPU/CUDA path — a node that only needs the floor keeps the lighter pin.
+onnxruntime>=1.24.4,<2
+onnxruntime-ep-webgpu>=0.4.0,<1

package/python/test_inference_pool_device_selection.py

@@ -232,6 +232,16 @@ class ResolveOnnxProvidersTest(unittest.TestCase):
             [ONNX_CPU_EP],
         )
 
+    def test_webgpu_pin_is_cpu_only_in_classic_resolver(self) -> None:
+        # WebGPU uses the plugin SessionOptions path; the classic resolver
+        # must not inject CUDA when device=webgpu (would race the plugin load).
+        self.assertEqual(
+            _resolve_onnx_providers(
+                "webgpu", "linux", "x86_64", [ONNX_CUDA_EP, ONNX_CPU_EP],
+            ),
+            [ONNX_CPU_EP],
+        )
+
     def test_cuda_pin_orders_cuda_first_cpu_last(self) -> None:
         self.assertEqual(
             _resolve_onnx_providers(

package/python/test_webgpu_isolated.py

@@ -0,0 +1,172 @@
+"""Unit tests for WebGPU process isolation (no real ORT/WebGPU required)."""
+from __future__ import annotations
+
+import io
+import pickle
+import struct
+import sys
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import webgpu_isolated as wi  # noqa: E402
+
+
+class FramingTests(unittest.TestCase):
+    def test_roundtrip(self) -> None:
+        buf = io.BytesIO()
+        payload = {"cmd": "predict", "inputs": {"x": [1, 2, 3]}}
+        wi._write_msg(buf, payload)
+        buf.seek(0)
+        self.assertEqual(wi._read_msg(buf), payload)
+
+    def test_eof(self) -> None:
+        with self.assertRaises(EOFError):
+            wi._read_msg(io.BytesIO(b""))
+
+    def test_short_reads_are_assembled(self) -> None:
+        """Pipe read() may return short; framing must loop until n bytes."""
+        payload = pickle.dumps({"ok": True, "n": 42}, protocol=pickle.HIGHEST_PROTOCOL)
+        frame = struct.pack(">I", len(payload)) + payload
+
+        class ShortReader:
+            def __init__(self) -> None:
+                self._data = frame
+                self._i = 0
+
+            def read(self, n: int) -> bytes:
+                # At most 3 bytes per call.
+                take = min(3, n, len(self._data) - self._i)
+                chunk = self._data[self._i : self._i + take]
+                self._i += take
+                return chunk
+
+        self.assertEqual(wi._read_msg(ShortReader()), {"ok": True, "n": 42})
+
+
+class IsolatedSessionTests(unittest.TestCase):
+    def test_open_load_predict_close(self) -> None:
+        replies = [
+            {
+                "ok": True,
+                "providers": ["WebGpuExecutionProvider", "CPUExecutionProvider"],
+                "input_name": "images",
+                "input_shape": [1, 3, 640, 640],
+                "input_type": "tensor(float)",
+                "output_names": ["output0"],
+            },
+            {"ok": True, "outputs": {"output0": [[0.1, 0.2]]}},
+            {"ok": True},
+        ]
+        written: list = []
+        resp_buf = bytearray()
+
+        class FakeIpcOut:
+            def write(self, b: bytes) -> int:
+                # Parse complete frames as they arrive and enqueue replies.
+                if not hasattr(self, "_req"):
+                    self._req = bytearray()
+                self._req.extend(b)
+                while len(self._req) >= 4:
+                    (size,) = struct.unpack(">I", self._req[:4])
+                    if len(self._req) < 4 + size:
+                        break
+                    msg = pickle.loads(bytes(self._req[4 : 4 + size]))
+                    del self._req[: 4 + size]
+                    written.append(msg)
+                    reply = pickle.dumps(replies.pop(0))
+                    resp_buf.extend(struct.pack(">I", len(reply)))
+                    resp_buf.extend(reply)
+                return len(b)
+
+            def flush(self) -> None:
+                pass
+
+            def close(self) -> None:
+                pass
+
+        class FakeIpcIn:
+            def read(self, n: int) -> bytes:
+                chunk = bytes(resp_buf[:n])
+                del resp_buf[:n]
+                return chunk
+
+            def close(self) -> None:
+                pass
+
+        proc = MagicMock()
+        proc.pid = 4242
+        proc.poll.return_value = None
+        proc.wait.return_value = 0
+
+        fake_out = FakeIpcOut()
+        fake_in = FakeIpcIn()
+        pipes = iter([(10, 11), (12, 13)])
+
+        def fake_pipe() -> tuple[int, int]:
+            return next(pipes)
+
+        with (
+            patch("webgpu_isolated.os.pipe", side_effect=fake_pipe),
+            patch("webgpu_isolated.os.close"),
+            patch("webgpu_isolated.os.fdopen", side_effect=[fake_out, fake_in]),
+            patch("webgpu_isolated.subprocess.Popen", return_value=proc),
+        ):
+            sess = wi.WebGpuIsolatedSession.open("/tmp/model.onnx", python_exe="python3")
+        self.assertEqual(sess.input_name, "images")
+        self.assertEqual(written[0]["cmd"], "load")
+        out = sess.run({"images": [[1.0]]})
+        self.assertEqual(out["output0"], [[0.1, 0.2]])
+        self.assertEqual(written[1]["cmd"], "predict")
+        sess.close()
+        self.assertEqual(written[2]["cmd"], "shutdown")
+
+    def test_load_failure_kills_child(self) -> None:
+        reply = pickle.dumps({"ok": False, "error": "boom"})
+        frame = struct.pack(">I", len(reply)) + reply
+
+        class FakeIpcOut:
+            def write(self, b: bytes) -> int:
+                return len(b)
+
+            def flush(self) -> None:
+                pass
+
+            def close(self) -> None:
+                pass
+
+        class FakeIpcIn:
+            def __init__(self) -> None:
+                self._data = frame
+                self._i = 0
+
+            def read(self, n: int) -> bytes:
+                chunk = self._data[self._i : self._i + n]
+                self._i += n
+                return chunk
+
+            def close(self) -> None:
+                pass
+
+        proc = MagicMock()
+        proc.pid = 1
+        proc.poll.return_value = None
+        proc.wait.return_value = 0
+        pipes = iter([(10, 11), (12, 13)])
+
+        with (
+            patch("webgpu_isolated.os.pipe", side_effect=lambda: next(pipes)),
+            patch("webgpu_isolated.os.close"),
+            patch("webgpu_isolated.os.fdopen", side_effect=[FakeIpcOut(), FakeIpcIn()]),
+            patch("webgpu_isolated.subprocess.Popen", return_value=proc),
+        ):
+            with self.assertRaises(RuntimeError) as ctx:
+                wi.WebGpuIsolatedSession.open("/tmp/x.onnx")
+        self.assertIn("boom", str(ctx.exception))
+        proc.kill.assert_called()
+
+
+if __name__ == "__main__":
+    unittest.main()