reactor-runtime 2.7.2__tar.gz → 2.7.4__tar.gz

{reactor_runtime-2.7.2 → reactor_runtime-2.7.4}/PKG-INFO

@@ -1,30 +1,30 @@
 Metadata-Version: 2.4
 Name: reactor_runtime
-Version: 2.7.2
+Version: 2.7.4
 Summary: Reactor runtime with public model API
 Author-email: Reactor <team@reactor.inc>
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: numpy>=1.24.0
-Requires-Dist: pydantic>=2.0.0
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: pydantic>=2.13.0
 Requires-Dist: omegaconf>=2.3.0
 Requires-Dist: av>=14.0.0
 Requires-Dist: aiortc>=1.14.0
-Requires-Dist: fastapi>=0.100.0
-Requires-Dist: uvicorn[standard]>=0.23.0
-Requires-Dist: aiohttp>=3.9.0
-Requires-Dist: httpx>=0.27.0
-Requires-Dist: redis
-Requires-Dist: jsonschema>=4.20.0
-Requires-Dist: opentelemetry-api~=1.39
-Requires-Dist: opentelemetry-sdk~=1.39
-Requires-Dist: opentelemetry-exporter-otlp-proto-http~=1.39
-Requires-Dist: opentelemetry-exporter-prometheus~=0.60b0
-Requires-Dist: grpcio>=1.60.0
-Requires-Dist: grpcio-health-checking
-Requires-Dist: opentelemetry-instrumentation-grpc~=0.60b0
+Requires-Dist: fastapi>=0.136.1
+Requires-Dist: uvicorn[standard]>=0.47.0
+Requires-Dist: aiohttp>=3.13.0
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: redis>=7.0.0
+Requires-Dist: jsonschema>=4.26.0
+Requires-Dist: opentelemetry-api~=1.42
+Requires-Dist: opentelemetry-sdk~=1.42
+Requires-Dist: opentelemetry-exporter-otlp-proto-http~=1.42
+Requires-Dist: opentelemetry-exporter-prometheus~=0.63b0
+Requires-Dist: grpcio>=1.80.0
+Requires-Dist: grpcio-health-checking>=1.80.0
+Requires-Dist: opentelemetry-instrumentation-grpc~=0.63b0
 Provides-Extra: gst
-Requires-Dist: PyGObject>=3.40.0; extra == "gst"
+Requires-Dist: PyGObject>=3.56.0; extra == "gst"
 
 # Reactor Runtime
 

{reactor_runtime-2.7.2 → reactor_runtime-2.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactor_runtime"
-version = "2.7.2"
+version = "2.7.4"
 description = "Reactor runtime with public model API"
 authors = [
 	{ name = "Reactor", email = "team@reactor.inc" }
@@ -13,29 +13,32 @@ readme = "README.md"
 requires-python = ">=3.9"
 
 dependencies = [
-	"numpy>=1.24.0",
-	"pydantic>=2.0.0",
-	"omegaconf>=2.3.0",
+    "numpy>=2.0.0",
+    "pydantic>=2.13.0",
+    "omegaconf>=2.3.0",
+    # PyAV is upper-bounded transitively by aiortc (<17). Keep our floor
+    # aligned with aiortc's own floor so any direct `av` resolution stays
+    # inside the supported range.
     "av>=14.0.0",
     "aiortc>=1.14.0",
-    "fastapi>=0.100.0",
-    "uvicorn[standard]>=0.23.0",
-	"aiohttp>=3.9.0",
-	"httpx>=0.27.0",
-	"redis",
-	"jsonschema>=4.20.0",
-	"opentelemetry-api~=1.39",
-	"opentelemetry-sdk~=1.39",
-	"opentelemetry-exporter-otlp-proto-http~=1.39",
-	"opentelemetry-exporter-prometheus~=0.60b0",
-	"grpcio>=1.60.0",
-	"grpcio-health-checking",
-	"opentelemetry-instrumentation-grpc~=0.60b0"
+    "fastapi>=0.136.1",
+    "uvicorn[standard]>=0.47.0",
+    "aiohttp>=3.13.0",
+    "httpx>=0.28.0",
+    "redis>=7.0.0",
+    "jsonschema>=4.26.0",
+    "opentelemetry-api~=1.42",
+    "opentelemetry-sdk~=1.42",
+    "opentelemetry-exporter-otlp-proto-http~=1.42",
+    "opentelemetry-exporter-prometheus~=0.63b0",
+    "grpcio>=1.80.0",
+    "grpcio-health-checking>=1.80.0",
+    "opentelemetry-instrumentation-grpc~=0.63b0",
 ]
 
 [project.optional-dependencies]
 gst = [
-	"PyGObject>=3.40.0",
+    "PyGObject>=3.56.0",
 ]
 
 # No `[project.scripts]` entry. The runtime is launched via

{reactor_runtime-2.7.2 → reactor_runtime-2.7.4}/src/reactor_runtime/recording/config.py

@@ -91,10 +91,11 @@ class RecordingConfig:
     # ``reactor.yaml``.
     chunk_seconds: int = 4
     clip_max_seconds: int = 300
-    # Trim the session-start pre-roll from clip playlists by clamping
-    # ``start_marker`` forward to the first real (non-duplicate) frame
-    # the recorder observes.  Set to ``False`` to keep that pre-roll
-    # in clips.
+    # Drop OutputBuffer gap-fill duplicates before the first real frame
+    # and anchor the recording timeline (markers + ffmpeg chunk 0) at
+    # that frame.  Clip requests before any real frame fail with
+    # ``no media generated yet``.  Set to ``False`` to record from
+    # session arm time and include the leading pre-roll in clips.
     skip_leading_black: bool = True
     video_track: Optional[str] = None
     audio_track: Optional[str] = None

reactor_runtime-2.7.4/src/reactor_runtime/recording/markers.py

@@ -0,0 +1,86 @@
+# Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
+"""Wall-clock marker bookkeeping for the recording subsystem.
+
+Markers are wall-clock seconds aligned with ffmpeg's
+``-use_wallclock_as_timestamps`` input.  When ``anchor_at_first_frame``
+is set (``RecordingConfig.skip_leading_black``), ``t=0`` is the first
+real frame fed to the encoder, not recorder arm time.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from typing import Optional, Tuple
+
+
+class MarkerBookkeeper:
+    """Tracks ``now_marker`` and the latest fully-uploaded chunk index.
+
+    Thread-safe — ``mark_chunk_uploaded`` is called from the uploader
+    thread while ``compute_*_range`` is called from the runtime's
+    asyncio loop on the inbound runtime-message dispatch path.
+    """
+
+    def __init__(self, *, anchor_at_first_frame: bool = False) -> None:
+        self._anchor_at_first_frame = anchor_at_first_frame
+        self._session_start = time.monotonic()
+        self._last_uploaded_chunk_idx: int = -1
+        self._recording_start: Optional[float] = None
+        self._first_real_frame_marker: Optional[float] = None
+        self._lock = threading.Lock()
+
+    def now_marker(self) -> float:
+        """Seconds since the active timeline origin."""
+        with self._lock:
+            origin = (
+                self._recording_start
+                if self._recording_start is not None
+                else self._session_start
+            )
+        return time.monotonic() - origin
+
+    @property
+    def last_uploaded_chunk_idx(self) -> int:
+        """Index of the most recent chunk known to be in the sink, or -1."""
+        with self._lock:
+            return self._last_uploaded_chunk_idx
+
+    @property
+    def first_real_frame_marker(self) -> Optional[float]:
+        """Session-relative time of the first real frame, or ``None``."""
+        with self._lock:
+            return self._first_real_frame_marker
+
+    @property
+    def recording_started(self) -> bool:
+        """False until the first real frame when ``anchor_at_first_frame``."""
+        if not self._anchor_at_first_frame:
+            return True
+        with self._lock:
+            return self._recording_start is not None
+
+    def mark_chunk_uploaded(self, idx: int) -> None:
+        """Advance ``last_uploaded_chunk_idx`` monotonically."""
+        with self._lock:
+            if idx > self._last_uploaded_chunk_idx:
+                self._last_uploaded_chunk_idx = idx
+
+    def mark_first_real_frame(self) -> None:
+        """Latch the first real frame; re-anchor timeline when configured."""
+        with self._lock:
+            if self._first_real_frame_marker is None:
+                self._first_real_frame_marker = time.monotonic() - self._session_start
+            if self._anchor_at_first_frame and self._recording_start is None:
+                self._recording_start = time.monotonic()
+
+    def compute_clip_range(self, duration_seconds: float) -> Tuple[float, float]:
+        """``(start_marker, end_marker)`` for a snap clip ending at ``now_marker``."""
+        end_marker = self.now_marker()
+        start_marker = max(0.0, end_marker - duration_seconds)
+        return start_marker, end_marker
+
+    def compute_recording_range(self) -> Tuple[float, float]:
+        """``(0, now_marker)`` for a full-session recording request."""
+        end_marker = self.now_marker()
+        return 0.0, end_marker

{reactor_runtime-2.7.2 → reactor_runtime-2.7.4}/src/reactor_runtime/recording/session_recorder.py

@@ -1,16 +1,14 @@
 # Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
-"""Public entrypoint that ties encoder, uploader, markers, and sink together.
-
-A :class:`SessionRecorder` is built per session by the runtime layer
-(``HttpRuntime`` for now, ``RedisRuntime`` later).  The runtime
-registers ``recorder._on_bundle_sync`` as an OutputBuffer callback so
-the recorder sees every frame the buffer emits — including gap-fill
-duplicates, which are recorded so the resulting file's wall-clock
-duration matches the live wire.
-
-``request_clip`` / ``request_recording`` are answered synchronously
-from the recorder's local state (no Supervisor RPC at clip-request
-time).
+"""Per-session recorder: encoder, uploader, markers, and sink.
+
+The runtime registers ``_on_bundle_sync`` on the model's
+:class:`~reactor_runtime.interface.output_buffer.OutputBuffer`.
+With ``skip_leading_black`` (default), gap-fill duplicates before the
+first real frame are dropped; after that, keepalive duplicates may be
+fed at a reduced rate during model idle periods.
+
+``request_clip`` / ``request_recording`` resolve from local marker
+state and return immediately (the SDK polls ``/clips`` for chunks).
 """
 
 from __future__ import annotations
@@ -47,6 +45,14 @@ class RecorderDisabledError(RuntimeError):
     """
 
 
+class NoMediaYetError(RecorderDisabledError):
+    """``request_clip`` / ``request_recording`` before the first real frame.
+
+    Distinct subclass so callers can disambiguate from encoder-crash
+    failures without string matching.
+    """
+
+
 @dataclass(frozen=True)
 class ClipResult:
     """Resolved outcome of a ``requestClip`` / ``requestRecording`` call.
@@ -59,8 +65,9 @@ class ClipResult:
     ``202 Retry-After`` while that chunk is in flight; the SDK polls
     until ``200``.
 
-    ``start_marker`` / ``end_marker`` / ``now_marker`` are session-
-    relative seconds (since recorder start).  ``predicted_ready_at_ms``
+    ``start_marker`` / ``end_marker`` / ``now_marker`` are seconds on the
+    recording timeline (``t=0`` at the first real frame when
+    ``skip_leading_black`` is on).  ``predicted_ready_at_ms``
     is a **Unix epoch in milliseconds** — the runtime's estimate of
     when the clip will be servable by ``/clips``.  An epoch lets the
     client decide independently whether to keep polling (epoch is
@@ -86,10 +93,6 @@ class ClipResult:
     now_marker: float
     predicted_ready_at_ms: int
     playlist_url: str
-    # Wall-clock of the first real (non-duplicate) frame the recorder
-    # observed, or ``None`` if none has landed yet.  Surfaced for
-    # observability; ``start_marker`` already uses it when
-    # ``RecordingConfig.skip_leading_black`` is on.
     first_real_frame_marker: Optional[float] = None
 
     def to_dict(self) -> dict:
@@ -134,7 +137,9 @@ class SessionRecorder:
         self._work_dir = Path(work_dir)
         self._work_dir.mkdir(parents=True, exist_ok=True)
 
-        self._markers = MarkerBookkeeper()
+        self._markers = MarkerBookkeeper(
+            anchor_at_first_frame=config.skip_leading_black
+        )
         self._encoder = ChunkEncoder(
             output_dir=self._work_dir,
             config=config,
@@ -151,10 +156,6 @@ class SessionRecorder:
         self._started = False
         self._disabled = False
 
-        # Bounded feed queue decouples the OutputBuffer emission thread
-        # from ffmpeg's blocking ``os.write``: when the encoder
-        # backpressures we drop from the *recording*, never the wire.
-        # Small on purpose — we want recent loss, not stale buffering.
         self._feed_queue: "queue.Queue[Optional[Tuple[np.ndarray, Optional[np.ndarray]]]]" = queue.Queue(
             maxsize=4
         )
@@ -162,27 +163,9 @@ class SessionRecorder:
         self._feed_stop = threading.Event()
         self._dropped_frames: int = 0
 
-        # Keepalive throttle for gap-fill duplicates.  Real frames are
-        # always passed through; duplicates (the OutputBuffer's own
-        # gap-fills when the model yields ``Idle`` or its inference
-        # generator stalls) are passed through at most once every
-        # ``keepalive_interval`` seconds — enough to keep ffmpeg's
-        # wallclock-stamped PTS advancing across HLS chunk boundaries
-        # so the marker math holds during long model pauses, without
-        # paying full-rate I/O for visually-identical frames.
         self._keepalive_interval = max(0.0, float(keepalive_interval))
         self._last_fed_t: float = 0.0
-        # Wall-clock of the previous video frame fed to the encoder.
-        # Used to compute the audio-fill sample count per video tick
-        # (``audio_sample_rate * dt``), which keeps audio DTS tracking
-        # video PTS 1:1 regardless of the model's instantaneous FPS.
         self._last_video_wall_t: float = 0.0
-
-        # Audio jitter buffer: model audio batches are variably sized;
-        # we accumulate them and emit ``round(sample_rate * dt)``
-        # samples per video tick (silence-pad on underrun, queue the
-        # surplus on overrun).  Capped at ~1 s so the recording can't
-        # accumulate unbounded audio latency.
         self._audio_jitter_buf: List[np.ndarray] = []
         self._audio_buffered_samples: int = 0
         self._audio_buffer_cap_samples: int = self._audio_sample_rate
@@ -230,32 +213,20 @@ class SessionRecorder:
         """
         if not self._started:
             return
-        # Disable callbacks first so a racing _on_bundle_sync becomes
-        # a no-op even before its OutputBuffer subscription is removed.
         self._disabled = True
-        # Signal the feed loop to drain and exit; sentinel unblocks .get().
         self._feed_stop.set()
         try:
             self._feed_queue.put_nowait(None)
         except queue.Full:
-            # Queue full → worker will see _feed_stop on its next iteration.
             pass
         feed_thread = self._feed_thread
         self._feed_thread = None
-        # Stop the encoder before joining the feed worker: the worker's
-        # blocking call is ``os.write()`` into the ffmpeg pipe and only
-        # unblocks when the pipe is closed.
         self._encoder.stop()
         if feed_thread is not None:
             feed_thread.join(timeout=2.0)
         feed_leaked = feed_thread is not None and feed_thread.is_alive()
         uploader_clean = self._uploader.stop(flush_remaining=True)
         self._started = False
-        # Cleanup the encoder's transient working dir.  Chunks that
-        # made it to the sink are already copied to the served dir;
-        # whatever's left here is leftover ffmpeg scratch (manifest.mpd,
-        # un-promoted .tmp segments, etc.) that we don't need.  Done
-        # AFTER ffmpeg exits so the muxer can't trip on the rmtree.
         try:
             shutil.rmtree(self._work_dir, ignore_errors=True)
         except Exception:
@@ -280,37 +251,18 @@ class SessionRecorder:
     # ------------------------------------------------------------------
 
     def _on_bundle_sync(self, bundle: MediaBundle, duplicate: bool) -> None:
-        """Per-tick callback registered on the model's :class:`OutputBuffer`.
-
-        Non-blocking: pushes onto the feed queue and returns.  The
-        ``recording-feed`` worker thread does the blocking ``os.write``
-        to ffmpeg.
-
-        **Real frames** (``duplicate=False``) are always passed through.
-
-        **Duplicates** (``duplicate=True``) are the OutputBuffer's
-        gap-fill emissions when the model yields :data:`Idle` or
-        otherwise fails to emit on a tick.  We rate-limit them to one
-        per ``_keepalive_interval`` seconds: enough to keep ffmpeg's
-        wallclock-stamped PTS advancing across HLS chunk boundaries
-        (so ``last_uploaded_chunk_idx`` keeps progressing during a
-        long model pause and the marker math holds), but cheap enough
-        not to burn full-rate pipe I/O on visually-identical frames.
-        """
+        """Enqueue a bundle for the feed worker; non-blocking."""
         if self._disabled or not self._started:
             return
         now = time.monotonic()
-        if not duplicate:
-            # Idempotent latch; only the first call takes effect.
-            self._markers.mark_first_real_frame()
         if duplicate:
+            if self._config.skip_leading_black and not self._markers.recording_started:
+                return
             if (
                 self._keepalive_interval <= 0.0
                 or (now - self._last_fed_t) < self._keepalive_interval
             ):
                 return
-        # Resolve tracks on the emission thread (cheap dict lookups);
-        # only the heavy os.write happens on the feed worker.
         video_td = bundle.tracks.get(self._video_track)
         if video_td is None:
             videos = bundle.get_tracks_by_kind(TrackKind.VIDEO)
@@ -322,12 +274,15 @@ class SessionRecorder:
             audio_td = bundle.tracks.get(self._audio_track)
             if audio_td is not None:
                 audio_data = audio_td.data
-        # The OutputBuffer's cache is per-model, so the first
-        # duplicates of a new session can carry the previous session's
-        # last frame.  Black-fill them until a real frame lands so the
-        # leading pre-roll is genuinely black rather than stale content.
         video_data = video_td.data
-        if duplicate and self._markers.first_real_frame_marker is None:
+        if (
+            duplicate
+            and not self._config.skip_leading_black
+            and self._markers.first_real_frame_marker is None
+        ):
+            # Legacy mode still records pre-roll; zero-fill so the
+            # OutputBuffer's per-model cache cannot leak the previous
+            # session's last frame into chunk 0.
             video_data = np.zeros_like(video_data)
             if audio_data is not None:
                 audio_data = np.zeros_like(audio_data)
@@ -335,33 +290,18 @@ class SessionRecorder:
             self._feed_queue.put_nowait((video_data, audio_data))
         except queue.Full:
             self._dropped_frames += 1
-            # Cold-start can fill the queue for a few hundred frames;
-            # throttle to avoid log spam.
             if self._dropped_frames == 1 or self._dropped_frames % 300 == 0:
                 logger.warning(
                     "Recorder feed queue full; dropping frame to keep wire path unblocked",
                     dropped_total=self._dropped_frames,
                 )
             return
-        # Update the keepalive watermark only when the bundle was
-        # actually accepted onto the queue.  If we update it on
-        # ``queue.Full`` we'd silently extend the keepalive window
-        # past the point where ffmpeg is healthy enough to drain.
+        if not duplicate:
+            self._markers.mark_first_real_frame()
         self._last_fed_t = now
 
     def _feed_loop(self) -> None:
-        """Worker thread: drains ``_feed_queue`` into the ffmpeg pipes.
-
-        No artificial pacing — ffmpeg uses
-        ``-use_wallclock_as_timestamps`` so it stamps PTS at pipe-read
-        time; we simply hand frames over as fast as the queue produces
-        them.  Per-frame audio fill is computed from wall-clock dt
-        between consecutive video frames so audio's byte-derived DTS
-        tracks video's PTS 1:1 regardless of dynamic FPS.
-
-        An encoder failure flips ``_disabled`` and exits the loop —
-        subsequent ``request_*`` calls will return ``clipFailed``.
-        """
+        """Drain ``_feed_queue`` into ffmpeg; disable on encoder failure."""
         while True:
             if self._feed_stop.is_set() and self._feed_queue.empty():
                 return
@@ -373,9 +313,6 @@ class SessionRecorder:
                 return
             video, audio = item
             now = time.monotonic()
-            # On the first frame we have no prior anchor; fall back to
-            # one ``1/30`` slot so the audio fill is non-zero.  After
-            # that, dt naturally tracks the model's dynamic cadence.
             dt = (
                 now - self._last_video_wall_t
                 if self._last_video_wall_t > 0.0
@@ -394,7 +331,6 @@ class SessionRecorder:
                     "Recorder encoder feed failed; disabling for this session"
                 )
                 self._disabled = True
-                # Drain the queue so producer side won't keep dropping.
                 try:
                     while True:
                         self._feed_queue.get_nowait()
@@ -417,15 +353,11 @@ class SessionRecorder:
         if target <= 0:
             return None
 
-        # Append any incoming model audio to the jitter buffer.
         if model_audio is not None and model_audio.size > 0:
             flat = np.ascontiguousarray(model_audio, dtype=np.int16).reshape(-1)
             self._audio_jitter_buf.append(flat)
             self._audio_buffered_samples += flat.size
 
-        # Trim the front of the buffer if it has grown beyond the cap;
-        # this caps recording latency at ~1 s of audio when the model
-        # bursts faster than video.
         while self._audio_buffered_samples > self._audio_buffer_cap_samples:
             head = self._audio_jitter_buf[0]
             drop = self._audio_buffered_samples - self._audio_buffer_cap_samples
@@ -436,7 +368,6 @@ class SessionRecorder:
                 self._audio_jitter_buf[0] = head[drop:]
                 self._audio_buffered_samples -= drop
 
-        # Pull exactly ``target`` samples; pad with silence on underrun.
         out = np.empty(target, dtype=np.int16)
         filled = 0
         while filled < target and self._audio_jitter_buf:
@@ -465,38 +396,31 @@ class SessionRecorder:
         ``/clips`` manifest endpoint will ``202 Retry-After`` until
         that chunk lands; the SDK polls until ``200``.
 
-        Honours :attr:`RecordingConfig.skip_leading_black`.
         """
         if self.disabled:
             raise RecorderDisabledError("recorder disabled or encoder crashed")
         capped = min(float(duration_seconds), float(self._config.clip_max_seconds))
         if capped <= 0:
             raise ValueError("duration_seconds must be positive")
-        start, end = self._markers.compute_clip_range(
-            capped, skip_leading_black=self._config.skip_leading_black
-        )
+        if not self._markers.recording_started:
+            raise NoMediaYetError("no media generated yet")
+        start, end = self._markers.compute_clip_range(capped)
         return self._build_result(kind=kind, start=start, end=end)
 
     def request_recording(self) -> ClipResult:
         """Resolve a full-recording request; ``end = now``.
 
-        Same promise-then-poll semantics as :meth:`request_clip` and
-        honours :attr:`RecordingConfig.skip_leading_black`.
+        Same promise-then-poll semantics as :meth:`request_clip`.
         """
         if self.disabled:
             raise RecorderDisabledError("recorder disabled or encoder crashed")
-        start, end = self._markers.compute_recording_range(
-            skip_leading_black=self._config.skip_leading_black
-        )
+        if not self._markers.recording_started:
+            raise NoMediaYetError("no media generated yet")
+        start, end = self._markers.compute_recording_range()
         return self._build_result(kind="recording", start=start, end=end)
 
     def _build_result(self, kind: str, start: float, end: float) -> ClipResult:
         now = self._markers.now_marker()
-        # Estimate when the in-progress chunk will close.  The
-        # dominant term is the time until the next chunk boundary; sink
-        # copy after that is sub-second on local fs and not modeled.
-        # If chunk_seconds isn't configured the estimate degenerates
-        # to "now" (the SDK should still poll /clips with backoff).
         cs = float(self._config.chunk_seconds)
         if cs > 0:
             next_boundary = (math.floor(now / cs) + 1) * cs
@@ -504,10 +428,6 @@ class SessionRecorder:
         else:
             wait_s = 0.0
         predicted_ready_at_ms = int(round((time.time() + wait_s) * 1000))
-        # ``kind`` is a body-only discriminator; keeping it out of the
-        # URL means identical content always has one canonical URL.
-        # The URL is path-only — the SDK prepends the runtime/Coordinator
-        # origin it already knows.  See ``ClipResult.playlist_url``.
         query = urlencode(
             {
                 "session_id": self._session_id,

{reactor_runtime-2.7.2 → reactor_runtime-2.7.4}/src/reactor_runtime/runtimes/http/http_runtime.py

@@ -904,6 +904,12 @@ class HttpRuntime(Runtime):
         asyncio.run_coroutine_threadsafe(self._stop_webrtc_client(), self.loop)
 
     def on_before_cleanup_complete(self, **kwargs) -> None:
+        # Belt-and-braces stop: also tear the recorder down here so
+        # session-end paths that bypass STOP_SESSION (notably the
+        # orphan-timeout path ORPHANED → CLOSING via TIMEOUT) can't
+        # leak the recorder.  ``_stop_recorder`` is idempotent so the
+        # normal STOP_SESSION path is a no-op here.  REA-2338.
+        self._stop_recorder()
         self._upload_store.clear()
 
     # -----------------------------------------------------------------

reactor_runtime-2.7.4/src/reactor_runtime/serve/__main__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
+"""Module entry point for `python -m reactor_runtime.serve`.
+
+Container CMDs and the Go CLI's docker-run dispatcher invoke this; nobody
+should call it as a console script (no `[project.scripts]` entry exists).
+The actual subcommand registration lives in `main.py` so it can be unit-
+tested without exec'ing the module.
+"""
+
+from reactor_runtime.serve.main import main
+
+if __name__ == "__main__":
+    main()