@camstack/addon-pipeline 1.2.350 → 1.2.351

package/dist/{custom-model-catalog-B1oKNuAa.js → custom-model-catalog-CPqbnIUh.js}

@@ -1857,7 +1857,7 @@ var MODEL_BY_CLASS = {
 	"intel-npu": "yolov9m-320-int8",
 	"intel-gpu": "yolov9m-320-int8",
 	"openvino-cpu": "yolov9m-320-int8",
-	"amd-igpu": "yolov9m-320",
+	"amd-igpu": "yolov9t-320",
 	cpu: null
 };
 /**

package/dist/{custom-model-catalog-XCE-YLb2.mjs → custom-model-catalog-DdHOXMKu.mjs}

@@ -1857,7 +1857,7 @@ var MODEL_BY_CLASS = {
 	"intel-npu": "yolov9m-320-int8",
 	"intel-gpu": "yolov9m-320-int8",
 	"openvino-cpu": "yolov9m-320-int8",
-	"amd-igpu": "yolov9m-320",
+	"amd-igpu": "yolov9t-320",
 	cpu: null
 };
 /**

package/dist/detection-pipeline/index.js

@@ -5,7 +5,7 @@ Object.defineProperties(exports, {
 const require_chunk = require("../chunk-emK7D4bc.js");
 const require_dist = require("../dist-C2jSMJo_.js");
 const require_node = require("../node-B7ZinEw5.js");
-const require_custom_model_catalog = require("../custom-model-catalog-B1oKNuAa.js");
+const require_custom_model_catalog = require("../custom-model-catalog-CPqbnIUh.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
 const require_process_memory = require("../process-memory-C1s8YIw4.js");
 let node_os = require("node:os");

package/dist/detection-pipeline/index.mjs

@@ -1,7 +1,7 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
 import { Gt as modelBindingKey, Hn as hydrateSchema, It as loadContributionCapability, Kn as nodePin, L as PoolMemoryWatchdog, Mn as errMsg$1, Pn as BaseAddon, Pt as linkedLabelStepId, Q as applyModelBoundSettings, Qt as pipelineExecutorCapability, Rn as createEvent, St as evaluateZoneRules, Y as YAMNET_TO_MACRO, Yn as sleep, Yt as pickClusterStepSettings, Zn as array, an as resolveClusterStepModelId, bn as supportedRuntimes$1, cr as EventCategory, ct as collectModelBoundKeys, d as CLUSTER_MODEL_SCOPED_STEPS, g as DEFAULT_CLUSTER_STEP_SETTINGS, hn as stepModelRunsOnFormat, jt as hfModelUrl, k as LABEL_SUPPLY_MACRO, lt as containingParentIndex, mn as runtimeDevices$1, n as APPLE_SA_TO_MACRO, or as string, pn as rootSuppliesOf, pt as defaultDeviceFor$1, qt as overlayClusterStepSettings, rr as object, sr as union, un as resolvePoolMemoryPolicy, vt as detectionPipelineCapability, xt as enumerateInferenceDevices } from "../dist-DFCl7PZV.mjs";
 import { s as readProcessCost } from "../node-C12l0K5V.mjs";
-import { C as resolveModelDefaultConfidence, S as landmarkPrecisionVerdict, _ as ALL_STEPS, b as getStepDefinition, f as localFrameRegistry, g as ALL_PIPELINE_STEPS, l as resolveDefaultDetectionModel, n as mergeCustomModels, o as deviceKeyOf, r as buildSubtreeCanRun, s as resolveDeviceEngine, t as CustomModelCatalog, u as macroGateVerdict, v as getDefaultModelForFormat, x as resolveModelForFormat, y as getStep } from "../custom-model-catalog-XCE-YLb2.mjs";
+import { C as resolveModelDefaultConfidence, S as landmarkPrecisionVerdict, _ as ALL_STEPS, b as getStepDefinition, f as localFrameRegistry, g as ALL_PIPELINE_STEPS, l as resolveDefaultDetectionModel, n as mergeCustomModels, o as deviceKeyOf, r as buildSubtreeCanRun, s as resolveDeviceEngine, t as CustomModelCatalog, u as macroGateVerdict, v as getDefaultModelForFormat, x as resolveModelForFormat, y as getStep } from "../custom-model-catalog-DdHOXMKu.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
 import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-3F1cP1ou.mjs";
 import * as os$1 from "node:os";

package/dist/pipeline-runner/index.js

@@ -5,7 +5,7 @@ Object.defineProperties(exports, {
 const require_chunk = require("../chunk-emK7D4bc.js");
 const require_dist = require("../dist-C2jSMJo_.js");
 const require_node = require("../node-B7ZinEw5.js");
-const require_custom_model_catalog = require("../custom-model-catalog-B1oKNuAa.js");
+const require_custom_model_catalog = require("../custom-model-catalog-CPqbnIUh.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
 const require_restream_intent = require("../restream-intent-7uDNqMKs.js");

package/dist/pipeline-runner/index.mjs

@@ -1,6 +1,6 @@
 import { $t as pipelineRunnerCapability, Bn as defineCustomActions, E as FailureCounters, Et as failureContributionCapability, Ft as linkedStepOf, I as PIPELINE_RAMP, It as loadContributionCapability, Kn as nodePin, M as NativeLeaseAdmissionSchema, Mn as errMsg, N as NativeLeaseSettingsSchema, P as NodeBenchRunnerInputSchema, Pn as BaseAddon, Qn as boolean, Rn as createEvent, U as ROOT_SUPPLIABLE_STEP_IDS, Xn as _enum, Xt as pickDetailCropConvention, Z as allowedSuppliedEffect, Zn as array, Zt as pickNativeLeaseOverride, _ as DEFAULT_DETAIL_CROP_CONVENTION, _t as deriveRootFaceRefineRect, a as BackgroundRunRegistry, cr as EventCategory, er as lazy, fn as resolveRootSupply, ht as deriveDetailCropRect, it as cameraOwnsMotionViaSensor, j as MODEL_FORMATS, ln as resolveModelBoundSetting, m as CROP_SUPPLY_SOURCES, nr as number, or as string, pn as rootSuppliesOf, rr as object, rt as buildBenchStepTree, tr as literal, x as DEVICE_RAMP, y as DEFAULT_NATIVE_LEASE_SETTINGS, zn as customAction } from "../dist-DFCl7PZV.mjs";
 import { i as NO_COST_CLAIM, t as ChildCostRegistry } from "../node-C12l0K5V.mjs";
-import { a as stepsForElectedPool, b as getStepDefinition, d as rootObjectGate, f as localFrameRegistry, h as resolveFrameViewGeometry, i as placeDetailStep, l as resolveDefaultDetectionModel, m as createSessionDecodeCoordinator, p as isSessionDecodeReadGone, s as resolveDeviceEngine, t as CustomModelCatalog, u as macroGateVerdict, y as getStep } from "../custom-model-catalog-XCE-YLb2.mjs";
+import { a as stepsForElectedPool, b as getStepDefinition, d as rootObjectGate, f as localFrameRegistry, h as resolveFrameViewGeometry, i as placeDetailStep, l as resolveDefaultDetectionModel, m as createSessionDecodeCoordinator, p as isSessionDecodeReadGone, s as resolveDeviceEngine, t as CustomModelCatalog, u as macroGateVerdict, y as getStep } from "../custom-model-catalog-DdHOXMKu.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
 import { c as withDetectionIntent, o as preRollRequestOf, t as DETECTION_PRE_ROLL_REQUEST_MS } from "../restream-intent-DyGmLAU9.mjs";

package/dist/stream-broker/{_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-VwFAKiPW.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.338",
+		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/{hostInit-CozpWK-g.mjs → hostInit-DfOhCBj-.mjs}

@@ -36,7 +36,7 @@ async function r() {
 				}
 			},
 			"@camstack/types": {
-				version: "1.2.338",
+				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/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-VwFAKiPW.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.350",
+  "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

@@ -448,9 +448,6 @@ def _resolve_ov_devices(available: list[str], full_names: dict[str, str]) -> lis
 ONNX_CUDA_EP = "CUDAExecutionProvider"
 ONNX_COREML_EP = "CoreMLExecutionProvider"
 ONNX_CPU_EP = "CPUExecutionProvider"
-# Plugin EP (onnxruntime-ep-webgpu) — registered at session load, not in
-# get_available_providers() until register_execution_provider_library runs.
-ONNX_WEBGPU_EP_REGISTRATION = "webgpu_ep_registration"
 
 
 def _resolve_onnx_providers(
@@ -471,8 +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 the plugin-EP SessionOptions
-        path in `_load_onnx_webgpu_session` (ORT ≥1.24 + onnxruntime-ep-webgpu).
+      - "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
@@ -503,55 +500,10 @@ def _resolve_onnx_providers(
     return providers
 
 
-def _load_onnx_webgpu_session(ort, path: str):
-    """Build an InferenceSession on the WebGPU plugin EP, CPU fallback on miss.
-
-    Registers `onnxruntime-ep-webgpu`, picks the first OrtEpDevice whose ep_name
-    matches the plugin, and attaches it via SessionOptions.add_provider_for_devices.
-    Any failure (missing wheel, no adapter, old ORT) falls back to CPU so the
-    pool still loads — the stderr line names which path won.
-    """
-    try:
-        import onnxruntime_ep_webgpu as webgpu_ep  # type: ignore
-    except Exception as err:
-        sys.stderr.write(f"ONNX WebGPU: plugin import failed ({err}); CPU fallback\n")
-        sys.stderr.flush()
-        return ort.InferenceSession(path, providers=[ONNX_CPU_EP]), [ONNX_CPU_EP]
-
-    try:
-        ort.register_execution_provider_library(
-            ONNX_WEBGPU_EP_REGISTRATION, webgpu_ep.get_library_path()
-        )
-    except Exception as err:
-        # Already registered across pool workers is fine; other errors → CPU.
-        msg = str(err).lower()
-        if "already" not in msg and "exist" not in msg:
-            sys.stderr.write(f"ONNX WebGPU: register failed ({err}); CPU fallback\n")
-            sys.stderr.flush()
-            return ort.InferenceSession(path, providers=[ONNX_CPU_EP]), [ONNX_CPU_EP]
-
-    ep_name = webgpu_ep.get_ep_name()
-    webgpu_device = next(
-        (d for d in ort.get_ep_devices() if getattr(d, "ep_name", None) == ep_name),
-        None,
-    )
-    if webgpu_device is None:
-        sys.stderr.write(
-            f"ONNX WebGPU: no OrtEpDevice for {ep_name!r} "
-            f"(Vulkan/libvulkan missing?); CPU fallback\n"
-        )
-        sys.stderr.flush()
-        return ort.InferenceSession(path, providers=[ONNX_CPU_EP]), [ONNX_CPU_EP]
-
-    sess_options = ort.SessionOptions()
-    sess_options.add_provider_for_devices([webgpu_device], {})
-    session = ort.InferenceSession(path, sess_options=sess_options)
-    active = list(session.get_providers())
-    sys.stderr.write(
-        f"ONNX WebGPU: providers={active} ep={ep_name} device=webgpu\n"
-    )
-    sys.stderr.flush()
-    return session, active
+# 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
 
 
 # ---------------------------------------------------------------------------
@@ -1388,13 +1340,32 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
         # 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":
-            session, active_list = _load_onnx_webgpu_session(ort, path)
+            # 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)\n"
+                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, _iso=isolated) -> dict:
+                return _iso.run(inp_dict)
+
+            slot.model = isolated
+            slot.predict_fn = predict
         else:
             try:
                 available_eps = list(ort.get_available_providers())
@@ -1412,29 +1383,29 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
                 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
+            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)}
+            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
+            slot.model = session
+            slot.predict_fn = predict
 
     elif _runtime == "edgetpu":
         Interpreter = _runtime_lib["Interpreter"]
@@ -1507,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/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()

package/python/webgpu_isolated.py

@@ -0,0 +1,292 @@
+"""
+WebGPU ORT sessions in a dedicated OS process.
+
+ORT WebGPU EP (Dawn/Vulkan) SIGSEGVs when a second InferenceSession is created
+in the same Python process (measured amd-proxmox 2026-10-10). Two processes,
+one session each, work concurrently. This module:
+
+  - loads a WebGPU session (or CPU fallback) — used by the child worker;
+  - hosts the child worker entrypoint (`python webgpu_isolated.py --ipc-in N --ipc-out M`);
+  - exposes `WebGpuIsolatedSession` for the pool parent: one child per model.
+
+IPC uses dedicated pipe fds (`pass_fds`), never stdin/stdout — ORT/Dawn log on
+fd 1 and a yolov9 raw head on a shared stdout pickle channel truncated the
+frame (2026-10-10). Pipe `read(n)` can also return short; framing uses
+`_read_exact`.
+
+OpenVINO / CoreML / classic ONNX stay in-process in inference_pool.py.
+"""
+from __future__ import annotations
+
+import os
+import pickle
+import struct
+import subprocess
+import sys
+import threading
+from typing import Any, BinaryIO, Optional
+
+ONNX_CPU_EP = "CPUExecutionProvider"
+ONNX_WEBGPU_EP_REGISTRATION = "webgpu_ep_registration"
+
+_HDR = struct.Struct(">I")
+
+
+def _read_exact(stream: BinaryIO, n: int) -> bytes:
+    """Read exactly n bytes; pipe read() may return short without EOF."""
+    buf = bytearray()
+    while len(buf) < n:
+        chunk = stream.read(n - len(buf))
+        if not chunk:
+            raise EOFError("webgpu worker closed")
+        buf.extend(chunk)
+    return bytes(buf)
+
+
+def _write_msg(stream: BinaryIO, obj: Any) -> None:
+    payload = pickle.dumps(obj, protocol=pickle.HIGHEST_PROTOCOL)
+    stream.write(_HDR.pack(len(payload)))
+    stream.write(payload)
+    stream.flush()
+
+
+def _read_msg(stream: BinaryIO) -> Any:
+    hdr = _read_exact(stream, _HDR.size)
+    (n,) = _HDR.unpack(hdr)
+    if n > 512 * 1024 * 1024:
+        raise RuntimeError(f"webgpu IPC frame too large: {n}")
+    data = _read_exact(stream, n)
+    return pickle.loads(data)
+
+
+def load_onnx_webgpu_session(ort: Any, path: str) -> tuple[Any, list[str]]:
+    """Build an InferenceSession on the WebGPU plugin EP, CPU fallback on miss.
+
+    Same contract as the former inference_pool._load_onnx_webgpu_session.
+    """
+    try:
+        import onnxruntime_ep_webgpu as webgpu_ep  # type: ignore
+    except Exception as err:
+        sys.stderr.write(f"ONNX WebGPU: plugin import failed ({err}); CPU fallback\n")
+        sys.stderr.flush()
+        return ort.InferenceSession(path, providers=[ONNX_CPU_EP]), [ONNX_CPU_EP]
+
+    try:
+        ort.register_execution_provider_library(
+            ONNX_WEBGPU_EP_REGISTRATION, webgpu_ep.get_library_path()
+        )
+    except Exception as err:
+        msg = str(err).lower()
+        if "already" not in msg and "exist" not in msg:
+            sys.stderr.write(f"ONNX WebGPU: register failed ({err}); CPU fallback\n")
+            sys.stderr.flush()
+            return ort.InferenceSession(path, providers=[ONNX_CPU_EP]), [ONNX_CPU_EP]
+
+    ep_name = webgpu_ep.get_ep_name()
+    webgpu_device = next(
+        (d for d in ort.get_ep_devices() if getattr(d, "ep_name", None) == ep_name),
+        None,
+    )
+    if webgpu_device is None:
+        sys.stderr.write(
+            f"ONNX WebGPU: no OrtEpDevice for {ep_name!r} "
+            f"(Vulkan/libvulkan missing?); CPU fallback\n"
+        )
+        sys.stderr.flush()
+        return ort.InferenceSession(path, providers=[ONNX_CPU_EP]), [ONNX_CPU_EP]
+
+    sess_options = ort.SessionOptions()
+    sess_options.add_provider_for_devices([webgpu_device], {})
+    session = ort.InferenceSession(path, sess_options=sess_options)
+    active = list(session.get_providers())
+    sys.stderr.write(f"ONNX WebGPU: providers={active} ep={ep_name} device=webgpu\n")
+    sys.stderr.flush()
+    return session, active
+
+
+def _parse_ipc_fds(argv: list[str]) -> tuple[int, int]:
+    ipc_in: Optional[int] = None
+    ipc_out: Optional[int] = None
+    i = 0
+    while i < len(argv):
+        if argv[i] == "--ipc-in" and i + 1 < len(argv):
+            ipc_in = int(argv[i + 1])
+            i += 2
+            continue
+        if argv[i] == "--ipc-out" and i + 1 < len(argv):
+            ipc_out = int(argv[i + 1])
+            i += 2
+            continue
+        i += 1
+    if ipc_in is None or ipc_out is None:
+        raise SystemExit("webgpu_isolated worker needs --ipc-in FD --ipc-out FD")
+    return ipc_in, ipc_out
+
+
+def _worker_main(argv: list[str]) -> None:
+    """One InferenceSession; commands on --ipc-in, replies on --ipc-out."""
+    import numpy as np
+    import onnxruntime as ort
+
+    fd_in, fd_out = _parse_ipc_fds(argv)
+    ipc_in = os.fdopen(fd_in, "rb", buffering=0)
+    ipc_out = os.fdopen(fd_out, "wb", buffering=0)
+
+    session = None
+    output_names: list[str] = []
+    while True:
+        try:
+            msg = _read_msg(ipc_in)
+        except EOFError:
+            break
+        cmd = msg.get("cmd")
+        if cmd == "shutdown":
+            _write_msg(ipc_out, {"ok": True})
+            break
+        if cmd == "load":
+            path = msg["path"]
+            try:
+                session, providers = load_onnx_webgpu_session(ort, path)
+                output_names = [o.name for o in session.get_outputs()]
+                inp = session.get_inputs()[0]
+                _write_msg(
+                    ipc_out,
+                    {
+                        "ok": True,
+                        "providers": providers,
+                        "input_name": inp.name,
+                        "input_shape": list(inp.shape),
+                        "input_type": inp.type,
+                        "output_names": output_names,
+                    },
+                )
+            except Exception as exc:
+                _write_msg(ipc_out, {"ok": False, "error": f"{type(exc).__name__}: {exc}"})
+            continue
+        if cmd == "predict":
+            if session is None:
+                _write_msg(ipc_out, {"ok": False, "error": "no session"})
+                continue
+            try:
+                outputs = session.run(output_names, msg["inputs"])
+                payload = {
+                    name: np.ascontiguousarray(out)
+                    for name, out in zip(output_names, outputs)
+                }
+                _write_msg(ipc_out, {"ok": True, "outputs": payload})
+            except Exception as exc:
+                _write_msg(ipc_out, {"ok": False, "error": f"{type(exc).__name__}: {exc}"})
+            continue
+        _write_msg(ipc_out, {"ok": False, "error": f"unknown cmd {cmd!r}"})
+
+
+class WebGpuIsolatedSession:
+    """Parent-side handle: one child process holding one WebGPU ORT session."""
+
+    def __init__(self, proc: subprocess.Popen, ipc_in: BinaryIO, ipc_out: BinaryIO, meta: dict):
+        self._proc = proc
+        self._ipc_in = ipc_in  # parent reads replies
+        self._ipc_out = ipc_out  # parent writes commands
+        self._lock = threading.Lock()
+        self.providers: list[str] = list(meta["providers"])
+        self.input_name: str = meta["input_name"]
+        self.input_shape = meta["input_shape"]
+        self.input_type: str = meta["input_type"]
+        self.output_names: list[str] = list(meta["output_names"])
+
+    @classmethod
+    def open(cls, path: str, *, python_exe: Optional[str] = None) -> "WebGpuIsolatedSession":
+        script = os.path.join(os.path.dirname(os.path.abspath(__file__)), "webgpu_isolated.py")
+        exe = python_exe or sys.executable
+        # cmd_r ← parent writes commands; reply_r ← parent reads replies
+        cmd_r, cmd_w = os.pipe()
+        reply_r, reply_w = os.pipe()
+        try:
+            proc = subprocess.Popen(
+                [exe, script, "--ipc-in", str(cmd_r), "--ipc-out", str(reply_w)],
+                pass_fds=(cmd_r, reply_w),
+                stdin=subprocess.DEVNULL,
+                stdout=None,  # inherit — ORT/Dawn logs stay in the pool log
+                stderr=None,
+                close_fds=True,
+            )
+        except Exception:
+            for fd in (cmd_r, cmd_w, reply_r, reply_w):
+                try:
+                    os.close(fd)
+                except OSError:
+                    pass
+            raise
+        # Parent keeps cmd_w + reply_r; close the ends the child owns.
+        os.close(cmd_r)
+        os.close(reply_w)
+        ipc_out = os.fdopen(cmd_w, "wb", buffering=0)
+        ipc_in = os.fdopen(reply_r, "rb", buffering=0)
+        try:
+            _write_msg(ipc_out, {"cmd": "load", "path": path})
+            reply = _read_msg(ipc_in)
+        except Exception:
+            ipc_out.close()
+            ipc_in.close()
+            proc.kill()
+            proc.wait(timeout=5)
+            raise
+        if not reply.get("ok"):
+            ipc_out.close()
+            ipc_in.close()
+            proc.kill()
+            proc.wait(timeout=5)
+            raise RuntimeError(reply.get("error") or "webgpu child load failed")
+        sys.stderr.write(
+            f"ONNX WebGPU: isolated child pid={proc.pid} providers={reply['providers']}\n"
+        )
+        sys.stderr.flush()
+        return cls(proc, ipc_in, ipc_out, reply)
+
+    def run(self, inputs: dict) -> dict:
+        with self._lock:
+            if self._proc.poll() is not None:
+                raise RuntimeError(
+                    f"webgpu child dead (exit={self._proc.returncode})"
+                )
+            _write_msg(self._ipc_out, {"cmd": "predict", "inputs": inputs})
+            reply = _read_msg(self._ipc_in)
+        if not reply.get("ok"):
+            raise RuntimeError(reply.get("error") or "webgpu predict failed")
+        return reply["outputs"]
+
+    def close(self) -> None:
+        proc = self._proc
+        if proc.poll() is not None:
+            try:
+                self._ipc_out.close()
+            except Exception:
+                pass
+            try:
+                self._ipc_in.close()
+            except Exception:
+                pass
+            return
+        try:
+            _write_msg(self._ipc_out, {"cmd": "shutdown"})
+            proc.wait(timeout=5)
+        except Exception:
+            pass
+        try:
+            self._ipc_out.close()
+        except Exception:
+            pass
+        try:
+            self._ipc_in.close()
+        except Exception:
+            pass
+        if proc.poll() is None:
+            proc.kill()
+            try:
+                proc.wait(timeout=5)
+            except Exception:
+                pass
+
+
+if __name__ == "__main__":
+    _worker_main(sys.argv[1:])