@camstack/addon-pipeline 1.2.360 → 1.2.361

package/dist/{segment-demux-js-W5FIgijf.mjs → segment-demux-js-C_27CmCq.mjs}

@@ -1,5 +1,5 @@
 import { r as __toESM, t as __commonJSMin } from "./chunk-DnnnRqeS.mjs";
-import { jn as errMsg } from "./dist-BYCrV0VR.mjs";
+import { On as errMsg } from "./dist-73R05PFN.mjs";
 import { spawn } from "node:child_process";
 //#region src/stream-broker/recorded/avcc-annexb.ts
 /**

package/dist/{segment-demux-js-BgDpp15L.js → segment-demux-js-Dr3e9r4m.js}

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-emK7D4bc.js");
-const require_dist = require("./dist-CYakbWA8.js");
+const require_dist = require("./dist-DFGiI5lr.js");
 let node_child_process = require("node:child_process");
 //#region src/stream-broker/recorded/avcc-annexb.ts
 /**

package/dist/stream-broker/{_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-v95KZ2Rt.mjs → _virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-DJeFG_hB.mjs}

@@ -18,7 +18,7 @@ var e = {
 	},
 	"@camstack/types": {
 		name: "@camstack/types",
-		version: "1.2.355",
+		version: "1.2.356",
 		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-BgDpp15L.js");
+const require_segment_demux_js = require("../segment-demux-js-Dr3e9r4m.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-W5FIgijf.mjs";
+import { t as demuxSegmentFullJs } from "../segment-demux-js-C_27CmCq.mjs";
 import { parentPort } from "node:worker_threads";
 //#region src/stream-broker/recorded/demux-worker-child.ts
 /**

package/dist/stream-broker/{hostInit-CDaDWDva.mjs → hostInit-Buho1uzb.mjs}

@@ -36,7 +36,7 @@ async function r() {
 				}
 			},
 			"@camstack/types": {
-				version: "1.2.355",
+				version: "1.2.356",
 				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-CYakbWA8.js");
-const require_node = require("../node-CTCm8Vtw.js");
+const require_dist = require("../dist-DFGiI5lr.js");
+const require_node = require("../node-CdOP9ELN.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-BgDpp15L.js");
+const require_segment_demux_js = require("../segment-demux-js-Dr3e9r4m.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, $t as rankStreams, An as DeviceType, At as gifFromMp4Args, Bn as expandAudioChunkToF32le, D as G711_SCALE_CORRECTION_DB, Dn as invocationFromEncodeProfile, Dt as ffmpegRate, Fn as CamProfileSchema, Gn as maskUrlCredentials, Hn as isEvent, It as loadContributionCapability, K as RingBuffer, Kn as nodePin, Ln as createEvent, Lt as logChannelsCapability, Mn as BOOT_RECOVERY_BACKOFF_MS, Nn as BaseAddon, On as isSoftwareDecode, Pn as CAM_PROFILE_ORDER, Qn as boolean, R as RATE_CONTROL_RELAXED, Sn as AUDIO_PRESETS, Tn as buildFfmpegArgs, Un as makeProfileBrokerId, Vt as memoizePinnedFfmpeg, Wn as makeSourceBrokerId, X as addonWidgetsSourceCapability, Xn as _enum, Zn as array, _n as streamBrokerCapability, ar as record, at as cameraStreamsCapability, bt as egressTransportFromRequest, c as CLIP_STILL_REASON_CODE_HEADER, cr as EventCategory, dt as createLogChannelsProvider, ft as declareLogChannel, jn as errMsg, kn as DeviceFeature, kt as gifDeriveSpeed, mt as deriveBatteryPresence, nr as number, nt as batteryCapability, o as BatteryStatusSchema, on as resolveEgressDecodeHwAccel, or as string, qn as parseProfileBrokerId, rr as object, s as CLIP_BROKER_PACED_RATES, sr as union, st as clipExportFailureOf, tr as literal, ut as createHwAccelCache, w as EncodeProfileSchema, xn as webrtcSessionCapability, yt as egressTranscodeSharingKey, z as RATE_CONTROL_TIGHT } from "../dist-BYCrV0VR.mjs";
-import { i as NO_COST_CLAIM, n as Fmp4FragmentChild, o as probeFfmpegBinary, r as Fmp4FragmentPlane, t as ChildCostRegistry } from "../node-C_qDNN9f.mjs";
+import { $n as discriminatedUnion, An as BaseAddon, D as G711_SCALE_CORRECTION_DB, Dn as DeviceType, Dt as gifDeriveSpeed, En as DeviceFeature, Gn as maskUrlCredentials, Hn as isEvent, I as RATE_CONTROL_RELAXED, In as createEvent, J as addonWidgetsSourceCapability, Kn as nodePin, L as RATE_CONTROL_TIGHT, Mn as CamProfileSchema, Nt as loadContributionCapability, On as errMsg, Ot as gifFromMp4Args, Pt as logChannelsCapability, Qn as boolean, Rt as memoizePinnedFfmpeg, Sn as buildFfmpegArgs, Tn as isSoftwareDecode, Tt as ffmpegRate, Un as makeProfileBrokerId, W as RingBuffer, Wn as makeSourceBrokerId, Xn as _enum, Xt as rankStreams, Zn as array, _t as egressTranscodeSharingKey, ar as record, at as clipExportFailureOf, c as CLIP_STILL_REASON_CODE_HEADER, cr as EventCategory, ct as createHwAccelCache, et as batteryCapability, ft as deriveBatteryPresence, jn as CAM_PROFILE_ORDER, kn as BOOT_RECOVERY_BACKOFF_MS, lt as createLogChannelsProvider, mn as streamBrokerCapability, nr as number, o as BatteryStatusSchema, or as string, qn as parseProfileBrokerId, rn as resolveEgressDecodeHwAccel, rr as object, rt as cameraStreamsCapability, s as CLIP_BROKER_PACED_RATES, sr as union, tr as literal, ut as declareLogChannel, vn as webrtcSessionCapability, vt as egressTransportFromRequest, w as EncodeProfileSchema, wn as invocationFromEncodeProfile, yn as AUDIO_PRESETS, zn as expandAudioChunkToF32le } from "../dist-73R05PFN.mjs";
+import { i as NO_COST_CLAIM, n as Fmp4FragmentChild, o as probeFfmpegBinary, r as Fmp4FragmentPlane, t as ChildCostRegistry } from "../node-C0-Ik_JH.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-W5FIgijf.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-C_27CmCq.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-v95KZ2Rt.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-DJeFG_hB.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

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

@@ -61,7 +61,6 @@ from __future__ import annotations
 import asyncio
 import concurrent.futures
 import contextlib
-import fcntl
 import gc
 import io
 import json
@@ -80,6 +79,7 @@ from typing import Any, Awaitable, Callable, Optional
 import numpy as np
 from PIL import Image
 
+import pool_platform
 from postprocessors import POSTPROCESSORS
 
 # ---------------------------------------------------------------------------
@@ -574,9 +574,12 @@ def compile_cache_lock(
         deadline = time.monotonic() + max(0.0, timeout_sec)
         while True:
             try:
-                fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
-                held = True
-                break
+                if pool_platform.try_lock_exclusive(handle.fileno()):
+                    held = True
+                    break
+                if time.monotonic() >= deadline:
+                    break
+                time.sleep(_COMPILE_CACHE_LOCK_POLL_SEC)
             except OSError:
                 if time.monotonic() >= deadline:
                     break
@@ -589,7 +592,7 @@ def compile_cache_lock(
         if handle is not None:
             try:
                 if held:
-                    fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+                    pool_platform.unlock(handle.fileno())
             except OSError:
                 pass
             try:
@@ -2344,6 +2347,9 @@ def _read_self_memory() -> dict:
     Partial results are fine — an empty dict means the read failed entirely.
     """
     out: dict = {}
+    if sys.platform == "win32":
+        # No `resource` and no /proc on Windows: psapi has the same numbers.
+        return pool_platform.read_windows_memory()
     try:
         import resource
 
@@ -3000,14 +3006,7 @@ class CommandRouter:
 
 async def _run() -> None:
     loop = asyncio.get_event_loop()
-    reader = asyncio.StreamReader(loop=loop)
-    protocol = asyncio.StreamReaderProtocol(reader, loop=loop)
-    await loop.connect_read_pipe(lambda: protocol, sys.stdin.buffer)
-
-    transport, stdout_protocol = await loop.connect_write_pipe(
-        asyncio.streams.FlowControlMixin, sys.stdout.buffer,
-    )
-    stream_writer = asyncio.StreamWriter(transport, stdout_protocol, None, loop)
+    reader, stream_writer = await pool_platform.open_stdio(loop)
     writer = ResponseWriter(stream_writer)
 
     t_start = time.perf_counter()

package/python/pool_platform.py

@@ -0,0 +1,214 @@
+"""The parts of the inference pool that differ between POSIX and Windows.
+
+Everything here is a seam with ONE job: keep `inference_pool.py` free of
+platform branches. On Linux/macOS each function delegates to the primitive the
+pool always used (`fcntl.flock`, asyncio's pipe transports, `resource`); on
+Windows it uses the closest equivalent that exists there. Nothing in this module
+changes what Linux or macOS do — the Windows branches are only reachable when
+`sys.platform == "win32"`, and each takes its platform as a parameter so a
+POSIX machine can test both.
+
+Why stdio is here too: the pool talks to its host over stdin/stdout, and
+asyncio's `connect_read_pipe` / `connect_write_pipe` cannot adopt the child end
+of a Node `child_process` pipe on Windows (the ProactorEventLoop needs an
+overlapped handle; that end is a plain synchronous one). The Windows branch
+reads stdin on a thread and writes stdout through an executor instead.
+"""
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures
+import os
+import sys
+from typing import Any, BinaryIO, Optional
+
+_READ_CHUNK = 1 << 16
+
+
+def is_windows(platform: Optional[str] = None) -> bool:
+    return (platform if platform is not None else sys.platform) == "win32"
+
+
+# ---------------------------------------------------------------------------
+# Advisory file lock (the per-model compile-cache lock)
+# ---------------------------------------------------------------------------
+
+
+def try_lock_exclusive(fd: int, platform: Optional[str] = None) -> bool:
+    """Take a NON-BLOCKING exclusive lock on `fd`; False when someone holds it.
+
+    POSIX: `flock(LOCK_EX | LOCK_NB)`. Windows: `msvcrt.locking(LK_NBLCK)` on the
+    first byte — byte-range locks are the only advisory primitive the C runtime
+    offers, and one byte is enough because the lock file is only ever a mutex.
+    Raises OSError for "unusable lock", exactly as `flock` did, so the caller's
+    "compile without the cache" path is unchanged.
+    """
+    if is_windows(platform):
+        import msvcrt
+
+        os.lseek(fd, 0, os.SEEK_SET)
+        try:
+            msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
+        except OSError:
+            return False
+        return True
+    import fcntl
+
+    try:
+        fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except BlockingIOError:
+        return False
+    return True
+
+
+def unlock(fd: int, platform: Optional[str] = None) -> None:
+    if is_windows(platform):
+        import msvcrt
+
+        os.lseek(fd, 0, os.SEEK_SET)
+        msvcrt.locking(fd, msvcrt.LK_UNLCK, 1)
+        return
+    import fcntl
+
+    fcntl.flock(fd, fcntl.LOCK_UN)
+
+
+# ---------------------------------------------------------------------------
+# Own-process memory (mem_stats)
+# ---------------------------------------------------------------------------
+
+
+def read_windows_memory() -> dict:
+    """Working set / peak working set / thread-less view of THIS process, in kB.
+
+    `GetProcessMemoryInfo` (psapi). Partial or empty on any failure — this rides
+    the mem_stats reply and must never raise.
+    """
+    out: dict = {}
+    try:
+        import ctypes
+        from ctypes import wintypes
+
+        class _Counters(ctypes.Structure):
+            _fields_ = [
+                ("cb", wintypes.DWORD),
+                ("PageFaultCount", wintypes.DWORD),
+                ("PeakWorkingSetSize", ctypes.c_size_t),
+                ("WorkingSetSize", ctypes.c_size_t),
+                ("QuotaPeakPagedPoolUsage", ctypes.c_size_t),
+                ("QuotaPagedPoolUsage", ctypes.c_size_t),
+                ("QuotaPeakNonPagedPoolUsage", ctypes.c_size_t),
+                ("QuotaNonPagedPoolUsage", ctypes.c_size_t),
+                ("PagefileUsage", ctypes.c_size_t),
+                ("PeakPagefileUsage", ctypes.c_size_t),
+            ]
+
+        counters = _Counters()
+        counters.cb = ctypes.sizeof(_Counters)
+        kernel = ctypes.WinDLL("kernel32", use_last_error=True)  # type: ignore[attr-defined]
+        psapi = ctypes.WinDLL("psapi", use_last_error=True)  # type: ignore[attr-defined]
+        kernel.GetCurrentProcess.restype = wintypes.HANDLE
+        psapi.GetProcessMemoryInfo.argtypes = [
+            wintypes.HANDLE,
+            ctypes.POINTER(_Counters),
+            wintypes.DWORD,
+        ]
+        if psapi.GetProcessMemoryInfo(
+            kernel.GetCurrentProcess(), ctypes.byref(counters), counters.cb
+        ):
+            out["rssKb"] = int(counters.WorkingSetSize // 1024)
+            out["hwmKb"] = int(counters.PeakWorkingSetSize // 1024)
+            out["maxRssKb"] = int(counters.PeakWorkingSetSize // 1024)
+            out["vmKb"] = int(counters.PagefileUsage // 1024)
+    except Exception:
+        pass
+    return out
+
+
+# ---------------------------------------------------------------------------
+# stdin / stdout transport
+# ---------------------------------------------------------------------------
+
+
+class ThreadedStdoutWriter:
+    """The slice of `asyncio.StreamWriter` the pool uses: `write` + `drain`.
+
+    `write` only buffers; `drain` hands the buffer to ONE worker thread, which
+    writes and flushes it, so a slow host stalls the awaiting coroutine and
+    never the event loop. A single worker keeps bytes in the order written.
+    """
+
+    def __init__(self, out: BinaryIO, loop: asyncio.AbstractEventLoop) -> None:
+        self._out = out
+        self._loop = loop
+        self._pending = bytearray()
+        self._executor = concurrent.futures.ThreadPoolExecutor(
+            max_workers=1, thread_name_prefix="pool-stdout"
+        )
+
+    def write(self, data: bytes) -> None:
+        self._pending += data
+
+    def _flush(self, data: bytes) -> None:
+        self._out.write(data)
+        self._out.flush()
+
+    async def drain(self) -> None:
+        if not self._pending:
+            return
+        data = bytes(self._pending)
+        self._pending.clear()
+        await self._loop.run_in_executor(self._executor, self._flush, data)
+
+
+def _pump_stdin(
+    fd: int, reader: asyncio.StreamReader, loop: asyncio.AbstractEventLoop
+) -> None:
+    """Thread body: stdin bytes -> the reader, EOF on close or error."""
+    try:
+        while True:
+            chunk = os.read(fd, _READ_CHUNK)
+            if not chunk:
+                break
+            loop.call_soon_threadsafe(reader.feed_data, chunk)
+    except OSError:
+        pass
+    finally:
+        try:
+            loop.call_soon_threadsafe(reader.feed_eof)
+        except RuntimeError:
+            pass  # the loop is already closed — nothing is waiting
+
+
+def open_threaded_stdio(
+    loop: asyncio.AbstractEventLoop, in_fd: int, out: BinaryIO
+) -> tuple[asyncio.StreamReader, Any]:
+    import threading
+
+    reader = asyncio.StreamReader(loop=loop)
+    threading.Thread(
+        target=_pump_stdin, args=(in_fd, reader, loop), name="pool-stdin", daemon=True
+    ).start()
+    return reader, ThreadedStdoutWriter(out, loop)
+
+
+async def open_stdio(
+    loop: asyncio.AbstractEventLoop, platform: Optional[str] = None
+) -> tuple[asyncio.StreamReader, Any]:
+    """(reader, writer) over this process's stdin/stdout, binary, on any OS."""
+    if is_windows(platform):
+        import msvcrt
+
+        # Belt and braces: Python already opens the std handles binary, but a
+        # CRLF translation on a length-prefixed protocol corrupts every frame.
+        msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
+        msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
+        return open_threaded_stdio(loop, sys.stdin.fileno(), sys.stdout.buffer)
+
+    reader = asyncio.StreamReader(loop=loop)
+    protocol = asyncio.StreamReaderProtocol(reader, loop=loop)
+    await loop.connect_read_pipe(lambda: protocol, sys.stdin.buffer)
+    transport, stdout_protocol = await loop.connect_write_pipe(
+        asyncio.streams.FlowControlMixin, sys.stdout.buffer
+    )
+    return reader, asyncio.StreamWriter(transport, stdout_protocol, None, loop)

package/python/test_inference_pool_windows.py

@@ -0,0 +1,86 @@
+"""inference_pool.py must import and serve its seams on a machine with no
+`fcntl` and no `resource` — which is what Windows is.
+
+The first test is the gate: it removes both modules from the importer's world
+(`sys.modules[name] = None` makes `import name` raise ImportError) and imports a
+fresh copy of the pool. A top-level `import fcntl` fails it, exactly as it
+failed the first Windows boot.
+
+Run: python3 -m unittest test_inference_pool_windows -v
+"""
+from __future__ import annotations
+
+import importlib
+import os
+import sys
+import tempfile
+import types
+import unittest
+from unittest import mock
+
+try:
+    import numpy  # noqa: F401
+except ImportError:
+    _np = types.ModuleType("numpy")
+    _np.float32 = float
+    _np.array = lambda values, dtype=None: values  # noqa: E731
+    sys.modules["numpy"] = _np
+
+try:
+    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
+
+if "postprocessors" not in sys.modules:
+    _pp = types.ModuleType("postprocessors")
+    _pp.POSTPROCESSORS = {}
+    sys.modules["postprocessors"] = _pp
+
+from test_pool_platform import FakeMsvcrt  # noqa: E402
+
+
+def import_pool_without_posix_modules() -> types.ModuleType:
+    sys.modules.pop("inference_pool", None)
+    with mock.patch.dict(sys.modules, {"fcntl": None, "resource": None}):
+        return importlib.import_module("inference_pool")
+
+
+class WindowsImportTest(unittest.TestCase):
+    def test_imports_with_no_fcntl_and_no_resource(self) -> None:
+        pool = import_pool_without_posix_modules()
+        self.assertTrue(callable(pool.compile_cache_lock))
+
+    def test_compile_lock_uses_the_windows_range_lock(self) -> None:
+        pool = import_pool_without_posix_modules()
+        fake = FakeMsvcrt()
+        with tempfile.TemporaryDirectory() as tmp, mock.patch.dict(
+            sys.modules, {"msvcrt": fake}
+        ), mock.patch.object(sys, "platform", "win32"):
+            with pool.compile_cache_lock(os.path.join(tmp, "cache"), "model") as held:
+                self.assertTrue(held)
+        self.assertEqual([c[1:] for c in fake.calls], [(2, 1), (0, 1)])
+
+    def test_compile_lock_gives_up_after_the_timeout_when_it_is_held(self) -> None:
+        pool = import_pool_without_posix_modules()
+        fake = FakeMsvcrt(busy=True)
+        with tempfile.TemporaryDirectory() as tmp, mock.patch.dict(
+            sys.modules, {"msvcrt": fake}
+        ), mock.patch.object(sys, "platform", "win32"):
+            with pool.compile_cache_lock(tmp, "model", timeout_sec=0.1) as held:
+                self.assertFalse(held)
+
+    def test_memory_read_on_windows_comes_from_psapi_and_skips_proc(self) -> None:
+        pool = import_pool_without_posix_modules()
+        sample = {"rssKb": 1024, "maxRssKb": 2048}
+        with mock.patch.object(sys, "platform", "win32"), mock.patch.object(
+            pool.pool_platform, "read_windows_memory", return_value=sample
+        ), mock.patch("builtins.open", side_effect=AssertionError("must not read /proc")):
+            self.assertEqual(pool._read_self_memory(), sample)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/test_pool_platform.py

@@ -0,0 +1,141 @@
+"""The POSIX/Windows seams of the inference pool (`pool_platform.py`).
+
+Both branches are exercised on whatever machine runs this: the Windows branch
+takes its platform as a parameter and a fake `msvcrt` module, so a Mac or a
+Linux box proves the dispatch, the byte-range lock calls and the threaded
+stdin/stdout transport. What it cannot prove is that `msvcrt.locking` and
+psapi behave as modelled on real Windows — that is the one thing still waiting
+for a Windows host.
+
+Run: python3 -m unittest test_pool_platform -v
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+import tempfile
+import types
+import unittest
+from unittest import mock
+
+import pool_platform
+
+
+class FakeMsvcrt(types.ModuleType):
+    LK_NBLCK = 2
+    LK_UNLCK = 0
+    O_BINARY = 0x8000
+
+    def __init__(self, busy: bool = False) -> None:
+        super().__init__("msvcrt")
+        self.busy = busy
+        self.calls: list[tuple[int, int, int]] = []
+        self.modes: list[tuple[int, int]] = []
+
+    def locking(self, fd: int, mode: int, nbytes: int) -> None:
+        self.calls.append((fd, mode, nbytes))
+        if self.busy and mode == self.LK_NBLCK:
+            raise OSError(13, "Permission denied")
+
+    def setmode(self, fd: int, flags: int) -> int:
+        self.modes.append((fd, flags))
+        return 0
+
+
+class IsWindowsTest(unittest.TestCase):
+    def test_follows_the_explicit_platform_then_sys_platform(self) -> None:
+        self.assertTrue(pool_platform.is_windows("win32"))
+        self.assertFalse(pool_platform.is_windows("linux"))
+        self.assertFalse(pool_platform.is_windows("darwin"))
+        with mock.patch.object(sys, "platform", "win32"):
+            self.assertTrue(pool_platform.is_windows())
+
+
+@unittest.skipIf(sys.platform == "win32", "flock is the POSIX branch")
+class PosixLockTest(unittest.TestCase):
+    def test_second_holder_is_refused_until_the_first_unlocks(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            path = os.path.join(tmp, "m.lock")
+            with open(path, "a+") as first, open(path, "a+") as second:
+                self.assertTrue(pool_platform.try_lock_exclusive(first.fileno()))
+                self.assertFalse(pool_platform.try_lock_exclusive(second.fileno()))
+                pool_platform.unlock(first.fileno())
+                self.assertTrue(pool_platform.try_lock_exclusive(second.fileno()))
+                pool_platform.unlock(second.fileno())
+
+
+class WindowsLockTest(unittest.TestCase):
+    def test_takes_a_one_byte_non_blocking_range_lock(self) -> None:
+        fake = FakeMsvcrt()
+        with tempfile.TemporaryFile() as handle, mock.patch.dict(sys.modules, {"msvcrt": fake}):
+            self.assertTrue(pool_platform.try_lock_exclusive(handle.fileno(), "win32"))
+            pool_platform.unlock(handle.fileno(), "win32")
+        self.assertEqual([c[1:] for c in fake.calls], [(2, 1), (0, 1)])
+
+    def test_a_held_lock_is_false_not_an_exception(self) -> None:
+        fake = FakeMsvcrt(busy=True)
+        with tempfile.TemporaryFile() as handle, mock.patch.dict(sys.modules, {"msvcrt": fake}):
+            self.assertFalse(pool_platform.try_lock_exclusive(handle.fileno(), "win32"))
+
+
+class ThreadedStdioTest(unittest.IsolatedAsyncioTestCase):
+    async def test_reader_gets_the_bytes_then_eof(self) -> None:
+        loop = asyncio.get_running_loop()
+        in_read, in_write = os.pipe()
+        out_read, out_write = os.pipe()
+        with os.fdopen(out_write, "wb") as out_file:
+            reader, writer = pool_platform.open_threaded_stdio(loop, in_read, out_file)
+            os.write(in_write, b"hello ")
+            os.write(in_write, b"world")
+            self.assertEqual(await asyncio.wait_for(reader.readexactly(11), 5), b"hello world")
+            os.close(in_write)
+            self.assertEqual(await asyncio.wait_for(reader.read(), 5), b"")
+            self.assertTrue(reader.at_eof())
+
+            writer.write(b"abc")
+            writer.write(b"def")
+            await writer.drain()
+            self.assertEqual(os.read(out_read, 6), b"abcdef")
+        os.close(out_read)
+        os.close(in_read)
+
+    async def test_writes_keep_their_order_across_drains(self) -> None:
+        loop = asyncio.get_running_loop()
+        in_read, in_write = os.pipe()
+        out_read, out_write = os.pipe()
+        with os.fdopen(out_write, "wb") as out_file:
+            _, writer = pool_platform.open_threaded_stdio(loop, in_read, out_file)
+            for chunk in (b"1", b"2", b"3"):
+                writer.write(chunk)
+                await writer.drain()
+            self.assertEqual(os.read(out_read, 3), b"123")
+        for fd in (in_write, in_read, out_read):
+            os.close(fd)
+
+    async def test_open_stdio_on_windows_sets_binary_mode_and_uses_the_threads(self) -> None:
+        loop = asyncio.get_running_loop()
+        fake = FakeMsvcrt()
+        in_read, in_write = os.pipe()
+        out_read, out_write = os.pipe()
+        with os.fdopen(out_write, "wb") as out_file:
+            fake_sys = types.SimpleNamespace(
+                stdin=types.SimpleNamespace(fileno=lambda: in_read),
+                stdout=types.SimpleNamespace(fileno=lambda: out_write, buffer=out_file),
+            )
+            with mock.patch.dict(sys.modules, {"msvcrt": fake}), mock.patch.object(
+                pool_platform, "sys", fake_sys
+            ), mock.patch.object(os, "O_BINARY", 0x8000, create=True):
+                reader, writer = await pool_platform.open_stdio(loop, "win32")
+            os.write(in_write, b"x")
+            self.assertEqual(await asyncio.wait_for(reader.readexactly(1), 5), b"x")
+            writer.write(b"y")
+            await writer.drain()
+            self.assertEqual(os.read(out_read, 1), b"y")
+        self.assertEqual([m[0] for m in fake.modes], [in_read, out_write])
+        for fd in (in_write, in_read, out_read):
+            os.close(fd)
+
+
+if __name__ == "__main__":
+    unittest.main()