railmux 0.3.6.dev2__tar.gz → 0.3.6.dev4__tar.gz

{railmux-0.3.6.dev2/src/railmux.egg-info → railmux-0.3.6.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.3.6.dev2
+Version: 0.3.6.dev4
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

railmux-0.3.6.dev4/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.6.dev4"

{railmux-0.3.6.dev2 → railmux-0.3.6.dev4}/src/railmux/fast_display_history.py

@@ -270,8 +270,6 @@ class LocalHistoryView:
         self,
         previous: HistorySnapshot,
         incoming: HistorySnapshot,
-        *,
-        prefer_deeper: bool = False,
     ) -> HistorySnapshot:
         """Retain already-fetched history when a later hot capture shrinks."""
         if not self._same_geometry(
@@ -280,28 +278,13 @@ class LocalHistoryView:
             return incoming
         delta = self._timeline_delta(previous.lines, incoming.lines)
         if delta is None:
-            if prefer_deeper and len(incoming.lines) > len(previous.lines):
-                # A deep response reaches here only after accept() proved that
-                # the user's immutable frozen viewport still exists in it.
-                # Rewind/full-screen diff output can make every individual
-                # line in that viewport non-unique, leaving the generic
-                # timeline voter without two anchors.  The larger cumulative
-                # capture is nevertheless stronger than the 300-line hot
-                # cache; keeping only its live tail would silently discard all
-                # intermediate output above the current screen.
-                lines = incoming.lines
-            else:
-                # Never splice two captures whose timelines cannot be aligned.
-                # Retaining old history and replacing only the live viewport
-                # looked conservative, but it silently omitted every row
-                # produced between those two pieces. That false seam appeared
-                # as discontinuous SSH history until returning to the bottom
-                # forced a fresh deep capture. Keep the newest internally
-                # contiguous hot capture instead; the first wheel-up requests
-                # a cumulative deep page and can recover older rows safely.
-                # An already-frozen viewport owns its immutable snapshot and
-                # therefore remains undisturbed by this cache replacement.
-                lines = incoming.lines
+            # Never splice two captures whose timelines cannot be aligned.
+            # Retaining old history and replacing only the live viewport
+            # looked conservative, but it silently omitted every row produced
+            # between those two pieces. Keep the newest internally contiguous
+            # capture instead. An already-frozen viewport owns its immutable
+            # snapshot and therefore remains undisturbed by cache replacement.
+            lines = incoming.lines
         else:
             start = min(0, delta)
             incoming_end = delta + len(incoming.lines)
@@ -329,8 +312,6 @@ class LocalHistoryView:
     def _remember_content(
         self,
         snapshot: HistorySnapshot,
-        *,
-        prefer_deeper: bool = False,
     ) -> HistorySnapshot:
         assert snapshot.pane_id is not None
         previous = self.content_cache.get(snapshot.pane_id)
@@ -348,8 +329,7 @@ class LocalHistoryView:
             stored = self._merge_content(previous, snapshot) if anchored else snapshot
             self._unverified_after_reconnect.discard(snapshot.pane_id)
         else:
-            stored = self._merge_content(
-                previous, snapshot, prefer_deeper=prefer_deeper)
+            stored = self._merge_content(previous, snapshot)
         # Reinsert an existing pane to keep insertion order as recency order.
         self.content_cache.pop(snapshot.pane_id, None)
         self.content_cache[snapshot.pane_id] = stored
@@ -485,7 +465,10 @@ class LocalHistoryView:
             cached = route
         loaded_limit = min(len(cached.lines), self.history_limit)
         target_lines = min(self.history_limit, _HISTORY_INITIAL_LINES)
-        if cached.more_available and loaded_limit < target_lines:
+        if (
+            cached.more_available
+            and loaded_limit < min(target_lines, _HISTORY_PREFETCH_LINES)
+        ):
             self.cancel_pane(route.pane_id)
             request_id = self._allocate_request_id()
             self._deep_pending[request_id] = _PendingHistory(
@@ -496,9 +479,9 @@ class LocalHistoryView:
                 max(1, initial_offset),
             )
             self._deep_requests += 1
-            # Keep the live pane intact until one internally contiguous deep
-            # capture arrives. Entering history atomically from that response
-            # removes the hot/deep seam and needs no moving-live anchor.
+            # A byte-budgeted or older peer may return less than the normal
+            # coherent routing capture. Keep the live pane intact until one
+            # cumulative response arrives rather than expose a short suffix.
             return HistoryAction(
                 protocol_frame=encode_history_request(
                     request_id, event.x, event.y, target_lines
@@ -525,22 +508,15 @@ class LocalHistoryView:
             ),
         )
         self.viewports[route.pane_id] = viewport
-        if loaded_limit >= target_lines:
-            return HistoryAction(
-                protocol_frame=self._extend_history(viewport, now=now),
-                render_history=True,
-            )
-        request_id = self._allocate_request_id()
-        self._deep_pending[request_id] = _PendingHistory(
-            self.route_epoch,
-            route.pane_id,
-            target_lines,
-            time.monotonic() if now is None else now,
-        )
-        self._deep_requests += 1
+        # A complete 300-row routing capture is already one coherent history
+        # source. Paint it synchronously, then fetch a cumulative page only as
+        # the viewport approaches its top. This removes an SSH round trip from
+        # the first wheel tick without reintroducing a hot/deep splice.
         return HistoryAction(
-            protocol_frame=encode_history_request(
-                request_id, event.x, event.y, target_lines
+            protocol_frame=self._extend_history(
+                viewport,
+                now=now,
+                request_position=(event.x, event.y),
             ),
             render_history=True,
         )
@@ -550,6 +526,7 @@ class LocalHistoryView:
         viewport: _HistoryViewport,
         *,
         now: float | None = None,
+        request_position: tuple[int, int] | None = None,
     ) -> bytes:
         """Request the next cumulative page when a viewport nears its top."""
         snapshot = viewport.snapshot
@@ -583,7 +560,9 @@ class LocalHistoryView:
             return b""
         target_lines = min(
             self.history_limit,
-            max(_HISTORY_INITIAL_LINES, viewport.loaded_limit) + _HISTORY_PAGE_LINES,
+            _HISTORY_INITIAL_LINES
+            if viewport.loaded_limit < _HISTORY_INITIAL_LINES
+            else viewport.loaded_limit + _HISTORY_PAGE_LINES,
         )
         request_id = self._allocate_request_id()
         self._deep_pending[request_id] = _PendingHistory(
@@ -593,10 +572,14 @@ class LocalHistoryView:
             requested_at,
         )
         self._deep_requests += 1
-        return encode_history_request(
-            request_id,
+        request_x, request_y = request_position or (
             snapshot.x + 1,
             snapshot.y + 1,
+        )
+        return encode_history_request(
+            request_id,
+            request_x,
+            request_y,
             target_lines,
         )
 
@@ -911,7 +894,11 @@ class LocalHistoryView:
             # snapshot instead of jumping to newer or unrelated text.
             self._anchor_rejects += 1
             return HistoryAction()
-        stored = self._remember_content(snapshot, prefer_deeper=True)
+        # The response is one cumulative capture and its exact visible anchor
+        # was just proved above. Replace the cached timeline as a whole instead
+        # of merging it with the older hot generation; this keeps every row's
+        # text and background styling from one server render.
+        stored = self._replace_content(snapshot)
         stored_offset = self._aligned_offset(stored, anchor)
         if stored_offset is None:
             # The raw response was valid, so this can only be an ambiguous
@@ -960,7 +947,7 @@ class LocalHistoryView:
             return matched_offset
 
         # Agent status rows (for example a Codex spinner) can change between
-        # the 300-line hot snapshot and the first deep response. Requiring the
+        # the hot snapshot and a deep response. Requiring the
         # entire visible viewport to remain byte-identical then strands the
         # user at the hot-cache boundary. Align on a majority of stable,
         # non-blank lines instead, but only when each evidence line occurs

{railmux-0.3.6.dev2 → railmux-0.3.6.dev4}/src/railmux/fast_display_server.py

@@ -1171,12 +1171,35 @@ def apply_path_open_request(
     )
 
 
-def _render_history_line(pyte: object, line: bytes, width: int) -> bytes:
-    """Parse one physical tmux line and emit only allowlisted SGR styling."""
+def _render_history_lines(
+    pyte: object,
+    lines: Sequence[bytes],
+    width: int,
+) -> tuple[bytes, ...]:
+    """Render physical tmux rows while retaining cross-row terminal style.
+
+    ``tmux capture-pane -e`` is a terminal stream, not a collection of
+    independently styled strings. In particular, tmux omits an SGR prefix
+    when a row inherits the previous row's foreground, background, or text
+    attributes. Keep one decoder alive for the ordered capture, but clear its
+    one-row cell buffer between rows. :func:`render_rows` then makes every
+    result independently paintable for the local history overlay.
+    """
     screen = pyte.Screen(width, 1)
     stream = pyte.ByteStream(screen)
-    stream.feed(line)
-    return render_rows(screen)[0]
+    rendered: list[bytes] = []
+    for line in lines:
+        screen.buffer[0].clear()
+        screen.cursor.x = 0
+        screen.cursor.y = 0
+        stream.feed(line)
+        rendered.append(render_rows(screen)[0])
+    return tuple(rendered)
+
+
+def _render_history_line(pyte: object, line: bytes, width: int) -> bytes:
+    """Render one self-contained physical row with allowlisted SGR styling."""
+    return _render_history_lines(pyte, (line,), width)[0]
 
 
 def _read_transcript_tail(fd: int) -> tuple[str, bool]:
@@ -1352,7 +1375,8 @@ def _capture_pane_history(
     # Retain the newest suffix when the styled representation reaches its byte
     # budget. Iterate backwards so an oversized response never sacrifices the
     # pane's current viewport merely to retain older scrollback.
-    current_raw = raw_lines[-pane.height :]
+    rendered_raw = _render_history_lines(pyte, raw_lines, pane.width)
+    current_raw = rendered_raw[-pane.height :]
     transcript_entry = None
     # ``None`` is retained only for old/test geometry that predates the
     # provider field; every validated live marker carries an explicit value.
@@ -1383,21 +1407,14 @@ def _capture_pane_history(
         transcript_lines = transcript_entry.rows
         history_count = max(0, max_lines - pane.height)
         source_lines = (
-            tuple((line, True) for line in transcript_lines[-history_count:])
-            if history_count
-            else ()
-        ) + tuple((line, False) for line in current_raw)
+            transcript_lines[-history_count:] if history_count else ()
+        ) + current_raw
     else:
-        source_lines = tuple((line, False) for line in raw_lines)
+        source_lines = rendered_raw
     newest_first: list[bytes] = []
     packed_size = 2  # history line-count prefix
     budget_truncated = False
-    for raw_line, rendered_already in reversed(source_lines[-max_lines:]):
-        rendered = (
-            raw_line
-            if rendered_already
-            else _render_history_line(pyte, raw_line, pane.width)
-        )
+    for rendered in reversed(source_lines[-max_lines:]):
         line_size = 4 + len(rendered)
         if packed_size + line_size > _HISTORY_SNAPSHOT_RAW_BUDGET:
             budget_truncated = True

{railmux-0.3.6.dev2 → railmux-0.3.6.dev4/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.3.6.dev2
+Version: 0.3.6.dev4
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

{railmux-0.3.6.dev2 → railmux-0.3.6.dev4}/tests/test_fast_full_window.py

@@ -2707,7 +2707,7 @@ def test_forced_policy_prefetch_preserves_other_pane_history_position():
     assert view.viewports["%7"].offset == 1
 
 
-def test_local_history_requests_deep_page_when_hot_viewport_fills_prefetch():
+def test_local_history_enters_warm_cache_immediately_then_prefetches_near_top():
     view = LocalHistoryView()
     prefetch = InputFrameDecoder().feed(view.begin_prefetch(1.0))[0]
     request_id, _limit = decode_history_prefetch(prefetch.data)
@@ -2717,17 +2717,26 @@ def test_local_history_requests_deep_page_when_hot_viewport_fills_prefetch():
         0,
         0,
         80,
-        300,
-        (b"live",) * 300,
+        30,
+        tuple(f"line-{index}".encode() for index in range(300)),
         more_available=True,
     )
     view.accept_prefetch(HistoryBatch(request_id, (route,)))
 
-    action = view.wheel(SgrMouseEvent(b"up", 64, 40, 2, True))
-    request = InputFrameDecoder().feed(action.protocol_frame)[0]
+    wheel = SgrMouseEvent(b"up", 64, 40, 2, True)
+    action = view.wheel(wheel)
+
+    assert action.render_history is True
+    assert action.protocol_frame == b""
+    assert view.overlays()[0][1][-1] == b"line-298"
 
+    request_action = HistoryAction()
+    for _ in range(200):
+        request_action = view.wheel(wheel)
+        if request_action.protocol_frame:
+            break
+    request = InputFrameDecoder().feed(request_action.protocol_frame)[0]
     assert decode_history_request(request.data)[3] == 2000
-    assert action.forwarded_input == b""
 
 
 def test_local_history_keeps_empty_plain_agent_wheel_from_tmux_copy_mode():
@@ -3594,7 +3603,7 @@ def test_unaligned_hot_prefetch_never_creates_a_discontinuous_history_seam():
         0,
         30,
         3,
-        tuple(f"old-{index}".encode() for index in range(300)),
+        tuple(f"old-{index}".encode() for index in range(200)),
         more_available=True,
     )
     view.accept_prefetch(HistoryBatch(first_id, (old,)))
@@ -3608,14 +3617,14 @@ def test_unaligned_hot_prefetch_never_creates_a_discontinuous_history_seam():
         0,
         30,
         3,
-        tuple(f"new-{index}".encode() for index in range(300)),
+        tuple(f"new-{index}".encode() for index in range(200)),
         more_available=True,
     )
     view.accept_prefetch(HistoryBatch(second_id, (current,)))
 
     wheel = view.wheel(SgrMouseEvent(b"up", 64, 40, 2, True))
 
-    # Do not briefly expose the 300-line hot suffix. It has no anchor to the
+    # Do not expose a short/incomplete hot suffix. It has no anchor to the
     # previous capture and an active provider may repaint again before the deep
     # response, which used to leave a visible gap until returning to bottom.
     assert not wheel.render_history
@@ -3635,14 +3644,14 @@ def test_unaligned_hot_prefetch_never_creates_a_discontinuous_history_seam():
         0,
         30,
         3,
-        tuple(f"deep-{index}".encode() for index in range(1700)) + current.lines,
+        tuple(f"deep-{index}".encode() for index in range(1800)) + current.lines,
     )
     accepted = view.accept(deep)
 
     assert accepted.render_history
     assert view.viewports["%8"].snapshot.lines == deep.lines
-    assert view.overlays()[0][1] == (b"new-295", b"new-296", b"new-297")
-    assert b"old-296" not in view.viewports["%8"].snapshot.lines
+    assert view.overlays()[0][1] == (b"new-195", b"new-196", b"new-197")
+    assert b"old-196" not in view.viewports["%8"].snapshot.lines
 
 
 def test_initial_deep_history_retry_and_wheel_down_are_bounded():
@@ -3654,7 +3663,7 @@ def test_initial_deep_history_retry_and_wheel_down_are_bounded():
         0,
         30,
         3,
-        tuple(f"line-{index}".encode() for index in range(300)),
+        tuple(f"line-{index}".encode() for index in range(200)),
         more_available=True,
     )
     view.visible_routes = (route,)
@@ -3740,6 +3749,12 @@ def test_periodic_hot_prefetch_does_not_shrink_a_reusable_deep_snapshot():
     view.accept_prefetch(HistoryBatch(first_id, (hot,)))
     wheel = SgrMouseEvent(b"up", 64, 40, 2, True)
     deep_action = view.wheel(wheel)
+    assert deep_action.render_history is True
+    assert deep_action.protocol_frame == b""
+    for _ in range(300):
+        deep_action = view.wheel(wheel)
+        if deep_action.protocol_frame:
+            break
     deep_id = decode_history_request(
         InputFrameDecoder().feed(deep_action.protocol_frame)[0].data
     )[0]
@@ -3788,10 +3803,11 @@ def test_validated_deep_capture_recovers_unanchored_rewind_output():
     first_id, _limit = decode_history_prefetch(first.data)
     repeated = b"\033[48;2;33;58;43mrewind-row"
     hot_lines = (
-        *(f"old-{index}".encode() for index in range(296)),
+        *(f"old-{index}".encode() for index in range(120)),
         repeated,
         repeated,
         repeated,
+        *(f"new-{index}".encode() for index in range(176)),
         b"live-bottom",
     )
     hot = HistorySnapshot(
@@ -3805,7 +3821,14 @@ def test_validated_deep_capture_recovers_unanchored_rewind_output():
         more_available=True,
     )
     view.accept_prefetch(HistoryBatch(first_id, (hot,)))
-    wheel = view.wheel(SgrMouseEvent(b"up", 64, 40, 2, True))
+    wheel_up = SgrMouseEvent(b"up", 64, 40, 2, True)
+    wheel = view.wheel(wheel_up)
+    assert wheel.render_history is True
+    assert wheel.protocol_frame == b""
+    for _ in range(300):
+        wheel = view.wheel(wheel_up)
+        if wheel.protocol_frame:
+            break
     request_id = decode_history_request(
         InputFrameDecoder().feed(wheel.protocol_frame)[0].data
     )[0]
@@ -6954,8 +6977,8 @@ def test_server_history_capture_honours_limits_above_the_old_4096_cap(
     )
     monkeypatch.setattr(
         fast_display_server,
-        "_render_history_line",
-        lambda _pyte, line, _width: line,
+        "_render_history_lines",
+        lambda _pyte, lines, _width: tuple(lines),
     )
 
     snapshot = fast_display_server._capture_pane_history(object(), pane, 7, 5000)
@@ -6996,16 +7019,31 @@ def test_server_raw_styled_hot_and_deep_history_keep_codex_foreground(
         b"\033[38;2;205;214;244mvalue = 1\033[39m"
     )
     monochrome = (
-        b"\033[48;5;22m 3 \033[0m\033[38;5;2m\033[48;5;22m"
+        # tmux omits the leading background because this physical row inherits
+        # it from ``highlighted``. History parsing must keep that stream state
+        # while still returning an independently paintable row.
+        b" 3 \033[0m\033[38;5;2m\033[48;5;22m"
         b"+#!/bin/bash\033[39m"
     )
+    removed = (
+        b"\033[48;5;52m 4 \033[0m\033[38;5;1m\033[48;5;52m"
+        b"-removed = True\033[39m"
+    )
+    removed_inherited = (
+        b" 5 \033[0m\033[38;5;1m\033[48;5;52m"
+        b"-removed = False\033[39m"
+    )
+    ordinary = b"\033[0m ordinary output"
     raw = b"\n".join((
         *(f"old-{index}".encode() for index in range(99)),
         wrap_head,
         wrap_continuation,
-        *(f"line-{index}".encode() for index in range(297)),
+        *(f"line-{index}".encode() for index in range(294)),
         highlighted,
         monochrome,
+        removed,
+        removed_inherited,
+        ordinary,
     )) + b"\n"
     monkeypatch.setattr(
         subprocess, "check_output", lambda *_args, **_kwargs: raw)
@@ -7031,19 +7069,32 @@ def test_server_raw_styled_hot_and_deep_history_keep_codex_foreground(
         terminal.ByteStream(screen).feed(row)
         return screen
 
-    highlighted_screen = styled_row(deep.lines[-2])
-    monochrome_screen = styled_row(deep.lines[-1])
+    highlighted_screen = styled_row(deep.lines[-5])
+    monochrome_screen = styled_row(deep.lines[-4])
+    removed_screen = styled_row(deep.lines[-3])
+    removed_inherited_screen = styled_row(deep.lines[-2])
+    ordinary_screen = styled_row(deep.lines[-1])
     highlighted_start = highlighted_screen.display[0].index("value")
     monochrome_start = monochrome_screen.display[0].index("#!/bin/bash")
     assert highlighted_screen.buffer[0][highlighted_start].fg == "cdd6f4"
     assert monochrome_screen.buffer[0][monochrome_start].fg == "00cd00"
+    assert highlighted_screen.buffer[0][0].bg == "005f00"
+    assert monochrome_screen.buffer[0][0].bg == "005f00"
+    assert removed_screen.buffer[0][0].bg == "5f0000"
+    assert removed_inherited_screen.buffer[0][0].bg == "5f0000"
+    assert ordinary_screen.buffer[0][0].bg == "default"
     coloured_backgrounds = {
         char.bg
-        for screen in (highlighted_screen, monochrome_screen)
+        for screen in (
+            highlighted_screen,
+            monochrome_screen,
+            removed_screen,
+            removed_inherited_screen,
+        )
         for char in screen.buffer[0].values()
         if char.bg != "default"
     }
-    assert coloured_backgrounds == {"005f00"}
+    assert coloured_backgrounds == {"005f00", "5f0000"}
 
 
 def test_server_claude_history_uses_stable_transcript_suffix(monkeypatch):
@@ -7074,8 +7125,8 @@ def test_server_claude_history_uses_stable_transcript_suffix(monkeypatch):
     )
     monkeypatch.setattr(
         fast_display_server,
-        "_render_history_line",
-        lambda _pyte, line, _width: line,
+        "_render_history_lines",
+        lambda _pyte, lines, _width: tuple(lines),
     )
 
     hot = fast_display_server._capture_pane_history(object(), pane, 1, 300)
@@ -7117,8 +7168,8 @@ def test_server_waits_for_local_choice_before_rendering_claude_transcript(
     )
     monkeypatch.setattr(
         fast_display_server,
-        "_render_history_line",
-        lambda _pyte, line, _width: line,
+        "_render_history_lines",
+        lambda _pyte, lines, _width: tuple(lines),
     )
 
     snapshot = fast_display_server._capture_pane_history(object(), pane, 1, 300)
@@ -7165,8 +7216,8 @@ def test_server_codex_history_uses_canonical_transcript_after_rewind(
     )
     monkeypatch.setattr(
         fast_display_server,
-        "_render_history_line",
-        lambda _pyte, line, _width: line,
+        "_render_history_lines",
+        lambda _pyte, lines, _width: tuple(lines),
     )
 
     snapshot = fast_display_server._capture_pane_history(
@@ -7207,8 +7258,8 @@ def test_server_unreadable_claude_transcript_preserves_native_wheel_fallback(
     )
     monkeypatch.setattr(
         fast_display_server,
-        "_render_history_line",
-        lambda _pyte, line, _width: line,
+        "_render_history_lines",
+        lambda _pyte, lines, _width: tuple(lines),
     )
 
     snapshot = fast_display_server._capture_pane_history(object(), pane, 1, 300)
@@ -7291,8 +7342,10 @@ def test_server_history_capture_truncates_to_newest_styled_byte_budget(
     line_bytes = fast_display_server._HISTORY_SNAPSHOT_RAW_BUDGET // 3 + 100
     monkeypatch.setattr(
         fast_display_server,
-        "_render_history_line",
-        lambda _pyte, line, _width: line + b"x" * line_bytes,
+        "_render_history_lines",
+        lambda _pyte, lines, _width: tuple(
+            line + b"x" * line_bytes for line in lines
+        ),
     )
 
     snapshot = fast_display_server._capture_pane_history(object(), pane, 7, 20000)

railmux-0.3.6.dev2/src/railmux/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.6.dev2"