NVIDIA
diff --git a/‎apps/cam2v/README.md‎
Lines changed: 28 additions & 8 deletions b/‎apps/cam2v/README.md‎
Lines changed: 28 additions & 8 deletions
diff --git a/‎apps/cam2v/__init__.py‎
Lines changed: 5 additions & 1 deletion b/‎apps/cam2v/__init__.py‎
Lines changed: 5 additions & 1 deletion
diff --git a/‎apps/cam2v/application.py‎
Lines changed: 1 addition & 11 deletions b/‎apps/cam2v/application.py‎
Lines changed: 1 addition & 11 deletions
diff --git a/‎apps/cam2v/controls.py‎
Lines changed: 63 additions & 90 deletions b/‎apps/cam2v/controls.py‎
Lines changed: 63 additions & 90 deletions
diff --git a/‎apps/cam2v/defaults.py‎
Lines changed: 8 additions & 8 deletions b/‎apps/cam2v/defaults.py‎
Lines changed: 8 additions & 8 deletions
@@ -6,16 +6,37 @@ Concrete integrations supply an existing runner config plus an input resolver
 that turns their asset format into `Cam2VConditioning`.
 
 The application owns the loaded pipeline. Each session owns its autoregressive
-cache, keyboard state, camera pose, and SlangPy UI overlay. The
-io-thread runs the UI loop over the current video frame; the
-model-generation-thread runs the model loop and is the only thread that mutates
-rollout state. Model status crosses to the UI loop through `invoke_async`
-messages.
+cache, keyboard state, camera pose, and SlangPy UI overlay. The UI thread draws
+the retained controls and status widgets over the current video frame; the model
+thread runs the model loop and is the only thread that mutates rollout state.
+Model status crosses to the UI loop through `invoke_async` messages.
+
+Browser keyboard events are reflected in the outgoing video through the
+`Active keys` status line. Arrow keys share the corresponding WASD state, and
+losing browser focus clears held controls.
 
 The overlay is enabled by default. Pass `-- --no-ui` after the application
 arguments to use the default model-output blitter for headless or benchmark
 runs.
 
+The recent model-rate status is the wall-time-weighted throughput of
+autoregressive steps whose completions fall in the trailing two seconds. It
+excludes between-step pacing, publication, UI, WebRTC, network, and browser
+display time. Integrations may enable one concise console record per AR step;
+the Lingbot specialization logs its warmup/steady phase, frame count,
+synchronized step wall time, and chunk FPS. Model metrics retain the
+warmup-excluded cumulative `steady_state_fps` metric for benchmark comparisons.
+
+Cam2V runs SlangPy rendering, model-frame conversion, and composition on a
+high-priority CUDA presentation stream. `CONTINUOUS` runs the UI every tick so
+browser input and time-driven status changes are reflected without waiting for
+a new model frame. The UI/write path owns output cadence; WebRTC does not pace
+frames again. It keeps two unsent frames in FIFO order and evicts the oldest
+queued frame on overflow. A frame already dequeued for the sender or encoder is
+committed and is outside that capacity. CUDA priority can overtake queued
+lower-priority kernels, but cannot preempt a model kernel that is already
+executing.
+
 For UI testing without loading a real model, run the packaged dummy pipeline:
 
 ```bash
@@ -24,9 +45,8 @@ uv run flashdreams-run-v2 cam2v-dummy --mode webrtc \
   --step-wait-seconds 0.9 --frames-per-chunk 12
 ```
 
-The model-generation-thread waits on a `threading.Event` for each synthetic
-step while the io-thread continues collecting browser input and presenting
-generated frames.
+The model thread waits on a `threading.Event` for each synthetic step while the
+UI thread continues collecting browser input and presenting generated frames.
 
 See `integrations_v2/cam2v_lingbot/cam2v_lingbot/app.py` for the minimal
 specialization pattern.
@@ -17,7 +17,11 @@
     Cam2VSessionConfig,
     CameraControlInput,
 )
-from .ui import Cam2VSlangPyUILoop, Cam2VUIState, Cam2VUIStatus
+from .ui import (
+    Cam2VSlangPyUILoop,
+    Cam2VUIState,
+    Cam2VUIStatus,
+)
 
 __all__ = [
     "Cam2VApplication",
 
@@ -36,7 +36,6 @@ def __init__(self, *, defaults: Cam2VApplicationDefaults) -> None:
         self._pipeline_config = defaults.pipeline_config
         self._device = defaults.device
         self._total_blocks = defaults.total_blocks
-        self._log_every_blocks = defaults.log_every_blocks
         self._warmup_blocks = defaults.warmup_blocks
         self._use_ui = True
         self._input_values: dict[str, Any] | None = None
@@ -101,12 +100,6 @@ def init(self, commandline_args: Sequence[str]) -> None:
             default=self.defaults.total_blocks,
             help="Autoregressive chunks generated per rollout. Default: %(default)s.",
         )
-        parser.add_argument(
-            "--log-every-blocks",
-            type=int,
-            default=self.defaults.log_every_blocks,
-            help="Emit live timing every N steady-state chunks.",
-        )
         parser.add_argument(
             "--warmup-blocks",
             type=int,
@@ -143,7 +136,6 @@ def init(self, commandline_args: Sequence[str]) -> None:
             )
         self._device = args.device
         self._total_blocks = args.total_blocks
-        self._log_every_blocks = args.log_every_blocks
         self._warmup_blocks = args.warmup_blocks
         self._use_ui = args.ui
         self._input_values = {
@@ -204,8 +196,8 @@ def create_session(self, session_desc: SessionDesc) -> ISession:
                 device=torch.device(self._device),
                 first_frame_dtype=self.defaults.first_frame_dtype,
                 first_frame_interpolation=self.defaults.first_frame_interpolation,
-                log_every_blocks=self._log_every_blocks,
                 warmup_blocks=self._warmup_blocks,
+                log_model_timing=self.defaults.log_model_timing,
                 install_hint=self.defaults.install_hint,
             ),
             use_ui=self._use_ui,
@@ -230,8 +222,6 @@ def _validate_arguments(self, args: argparse.Namespace) -> None:
         """Reject invalid rollout and timing settings."""
         if args.total_blocks <= 0:
             raise ValueError("--total-blocks must be > 0.")
-        if args.log_every_blocks <= 0:
-            raise ValueError("--log-every-blocks must be > 0.")
         if args.warmup_blocks < 0:
             raise ValueError("--warmup-blocks must be >= 0.")
         if args.world_scale is not None and args.world_scale < 0:
 
@@ -5,34 +5,29 @@
 
 from __future__ import annotations
 
-from collections import deque
 from dataclasses import dataclass, field
-from typing import Literal
+from typing import Literal, TypeAlias
 
 import numpy as np
 
 from flashdreams.runtime.keyboard import DEFAULT_SUPPORTED_KEYS, KeyboardState
+from flashdreams.runtime_v2.input_timeline import RealtimeInputTimeline
+from flashdreams.runtime_v2.keyboard_input import (
+    KeyboardStateSegment,
+    KeyboardStateTrack,
+)
 
-PoseSegment = tuple[float, float, frozenset[str]]
+PoseSegment: TypeAlias = KeyboardStateSegment
 """One time interval and the camera-control keys held throughout it."""
 
 
-@dataclass(frozen=True, slots=True)
-class _KeyboardEdge:
-    """One timestamped keyboard state transition."""
-
-    arrival_t: float
-    """Seconds since the WebRTC session began."""
-
-    event: str
-    """KeyboardState transition or the internal ``release_all`` action."""
-
-    key: str | None = None
-    """Browser key identifier, or ``None`` for ``release_all``."""
-
-
 class KeyboardResampler:
-    """Resample sparse key-down/key-up edges into a camera-control timeline."""
+    """Preserve Cam2V's legacy combined keyboard-resampler API.
+
+    New model-loop code uses :attr:`input_timeline` and
+    :attr:`keyboard_track` separately. The combined surface remains for
+    existing Cam2V and Lingbot callers.
+    """
 
     def __init__(
         self,
@@ -41,95 +36,73 @@ def __init__(
         start_v: float = 0.0,
         supported_keys: frozenset[str] = DEFAULT_SUPPORTED_KEYS,
     ) -> None:
-        if fps <= 0:
-            raise ValueError("fps must be > 0")
-        self._fps = float(fps)
-        self._dt = 1.0 / self._fps
-        self._supported_keys = supported_keys
-        self.next_chunk_start_v = start_v
-        self._event_log: deque[_KeyboardEdge] = deque()
-        self._carried_state = KeyboardState(supported_keys=supported_keys)
+        self._input_timeline = RealtimeInputTimeline(
+            samples_per_second=fps,
+            start_s=start_v,
+        )
+        self._keyboard_track = KeyboardStateTrack(
+            supported_keys=supported_keys,
+            state_projection=KeyboardState.resolved_effective_keys,
+        )
 
     @property
     def fps(self) -> float:
-        """Return the target camera sampling rate."""
-        return self._fps
+        """Return the target keyboard sampling rate."""
+        return self._input_timeline.samples_per_second
 
     @property
     def dt(self) -> float:
-        """Return the interval between adjacent camera samples."""
-        return self._dt
+        """Return the interval between adjacent keyboard samples."""
+        return self._input_timeline.sample_interval_s
+
+    @property
+    def input_timeline(self) -> RealtimeInputTimeline:
+        """Return the modality-neutral clock backing this compatibility view."""
+        return self._input_timeline
+
+    @property
+    def keyboard_track(self) -> KeyboardStateTrack:
+        """Return the keyboard state track backing this compatibility view."""
+        return self._keyboard_track
+
+    @property
+    def next_chunk_start_v(self) -> float:
+        """Return the start of the next legacy sampling chunk."""
+        return self._input_timeline.next_window_start_s
+
+    @next_chunk_start_v.setter
+    def next_chunk_start_v(self, value: float) -> None:
+        """Move the legacy sampling cursor without clearing keyboard state."""
+        self._input_timeline.reset(start_s=value)
 
     def on_edge(self, *, arrival_t: float, event: str, key: str) -> None:
         """Record one keyboard edge in timestamp order."""
-        self._record_edge(_KeyboardEdge(arrival_t, event, key))
+        self._keyboard_track.on_edge(
+            timestamp_s=arrival_t,
+            action=event,
+            key=key,
+        )
 
     def release_all(self, *, arrival_t: float) -> None:
-        """Release every held key at ``arrival_t``, such as on focus loss."""
-        self._record_edge(_KeyboardEdge(arrival_t, "release_all"))
+        """Release every held key at ``arrival_t``."""
+        self._keyboard_track.release_all(timestamp_s=arrival_t)
 
-    def _record_edge(self, edge: _KeyboardEdge) -> None:
-        """Insert ``edge`` while preserving timestamp order."""
-        if not self._event_log or edge.arrival_t >= self._event_log[-1].arrival_t:
-            self._event_log.append(edge)
-            return
-        for index, queued_edge in enumerate(self._event_log):
-            if edge.arrival_t < queued_edge.arrival_t:
-                self._event_log.insert(index, edge)
-                return
-        self._event_log.append(edge)
-
-    def _apply_edge(self, edge: _KeyboardEdge) -> None:
-        """Apply one queued edge to the carried keyboard state."""
-        if edge.event == "release_all":
-            self._carried_state = KeyboardState(
-                supported_keys=self._supported_keys,
-            )
-            return
-        assert edge.key is not None
-        self._carried_state.apply_event(event=edge.event, key=edge.key)
-
-    def sample_chunk(self, num_frames: int) -> tuple[list[PoseSegment], list[float]]:
-        """Return key-state segments and sample times for one model chunk."""
-        if num_frames < 1:
-            raise ValueError("num_frames must be >= 1")
-
-        chunk_start_v = self.next_chunk_start_v
-        chunk_end_v = chunk_start_v + num_frames * self._dt
-        while self._event_log and self._event_log[0].arrival_t < chunk_start_v:
-            self._apply_edge(self._event_log.popleft())
-
-        segments: list[PoseSegment] = []
-        previous_t = chunk_start_v
-        previous_state = self._carried_state.resolved_effective_keys()
-        while self._event_log and self._event_log[0].arrival_t <= chunk_end_v:
-            edge = self._event_log.popleft()
-            event_t = edge.arrival_t
-            if event_t > previous_t:
-                segments.append((previous_t, event_t, previous_state))
-            self._apply_edge(edge)
-            previous_state = self._carried_state.resolved_effective_keys()
-            previous_t = event_t
-        if previous_t < chunk_end_v:
-            segments.append((previous_t, chunk_end_v, previous_state))
-        elif not segments:
-            segments.append((chunk_start_v, chunk_end_v, previous_state))
-
-        frame_times = [
-            chunk_start_v + (index + 1) * self._dt for index in range(num_frames)
-        ]
-        self.next_chunk_start_v = chunk_end_v
-        return segments, frame_times
+    def sample_chunk(
+        self,
+        num_frames: int,
+    ) -> tuple[list[KeyboardStateSegment], list[float]]:
+        """Return key-state segments and sample times for one legacy chunk."""
+        window = self._input_timeline.next_window(num_frames)
+        return self._keyboard_track.segments(window), list(window.sample_times_s)
 
     def reset(self, *, start_v: float) -> None:
-        """Discard queued edges and restart the virtual camera clock."""
-        self._event_log.clear()
-        self._carried_state = KeyboardState(supported_keys=self._supported_keys)
-        self.next_chunk_start_v = start_v
+        """Discard queued edges and restart the legacy sampling clock."""
+        self._keyboard_track.reset()
+        self._input_timeline.reset(start_s=start_v)
 
     def event_log_size(self) -> int:
         """Return the number of keyboard edges awaiting consumption."""
-        return len(self._event_log)
+        return self._keyboard_track.pending_event_count
 
 
 def _rotation_matrix(axis: str, angle_rad: float) -> np.ndarray:
 
@@ -88,18 +88,18 @@ class Cam2VApplicationDefaults:
     backpressure_mode: BackpressureMode = BackpressureMode.BLOCK
     """Preserve every generated model frame in presentation order."""
 
-    presentation_mode: PresentationMode = PresentationMode.ONLY_PRESENT_NEW
-    """Render and transmit the overlay once for each selected model frame."""
+    presentation_mode: PresentationMode = PresentationMode.CONTINUOUS
+    """Render the UI every tick so controls and status remain responsive."""
 
     ui_fps: int = 60
-    """Rate at which the io-thread reads inputs and runs the UI loop."""
-
-    log_every_blocks: int = 1
-    """Default interval between steady-state timing log records."""
+    """Rate at which the UI thread reads inputs and runs the UI loop."""
 
     warmup_blocks: int = 5
     """Leading blocks excluded from steady-state FPS."""
 
+    log_model_timing: bool = False
+    """Write one synchronized wall-time record for each AR model step."""
+
     install_hint: str = ""
     """Optional dependency hint included in first-frame loading failures."""
 
@@ -113,10 +113,10 @@ def __post_init__(self) -> None:
             raise ValueError("Cam2VApplicationDefaults dimensions must be > 0.")
         if self.fps <= 0 or self.ui_fps <= 0:
             raise ValueError("Cam2VApplicationDefaults frame rates must be > 0.")
-        if self.log_every_blocks <= 0:
-            raise ValueError("Cam2VApplicationDefaults.log_every_blocks must be > 0.")
         if self.warmup_blocks < 0:
             raise ValueError("Cam2VApplicationDefaults.warmup_blocks must be >= 0.")
+        if not isinstance(self.log_model_timing, bool):
+            raise TypeError("Cam2VApplicationDefaults.log_model_timing must be bool.")
         object.__setattr__(
             self,
             "input_defaults",