railmux 0.4.0.dev15__tar.gz → 0.4.0.dev17__tar.gz

{railmux-0.4.0.dev15/src/railmux.egg-info → railmux-0.4.0.dev17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev15
+Version: 0.4.0.dev17
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT
@@ -170,7 +170,7 @@ for focus and layout limits.
 |--------|--------|
 | Left-click (non-running) | Preview session history in the Target pane |
 | Left-click (running) | Switch the Target pane to that session |
-| Wheel up over a live agent | Open its canonical current-branch history |
+| Wheel over a live agent | Scroll its live terminal history (native locally, Railmux-managed over `railmux ssh`) |
 | Double-click | Open/attach in the Target pane and move focus there |
 | Right-click | Context menu (Open, Preview, Info, Rename, Star, Copy title, Kill, Term, Delete) |
 
@@ -373,16 +373,21 @@ sessions move ahead of the other results.
 
 For a stopped session, left-click or press `␣` to view conversation history in
 the Target pane without starting or resuming the agent. For a running session,
-press `␣`, choose **Preview**, or wheel up over its live pane. Preview is
-read-only: it cannot send a message or change the session. User and assistant
-messages, tool calls, and abbreviated tool output are colour-coded, while
-internal context and encrypted reasoning are hidden. Codex rewind lineages and
-Claude Code `parentUuid` branches are projected onto the provider's current
-conversation: the retained prefix and replacement suffix remain visible, while
-the abandoned suffix is hidden. When Railmux observes a running Codex session
-advance after rewind or steering, it resets only the current terminal view
-before Codex redraws. Retained tmux scrollback is not erased, and managed
-history continues from the canonical rollout without its abandoned suffix.
+press `␣` or choose **Preview**. Preview is read-only: it cannot send a message
+or change the session. User and assistant messages, tool calls, and abbreviated
+tool output are colour-coded, while internal context and encrypted reasoning
+are hidden. Codex rewind lineages and Claude Code `parentUuid` branches are
+projected onto the provider's current conversation: the retained prefix and
+replacement suffix remain visible, while the abandoned suffix is hidden.
+
+Scrolling a live agent does not enter Preview. Direct `railmux` uses the
+terminal/tmux scrolling behavior; `railmux ssh` keeps its own bounded,
+per-pane history and normally preserves the live terminal's captured styling.
+When Railmux confirms that a running Codex session advanced after rewind or
+steering, it resets only the current terminal view before Codex redraws and
+invalidates that pane's SSH history generation. Retained tmux scrollback is not
+erased; the SSH history for that branched generation uses the canonical
+rollout so its abandoned suffix stays hidden.
 
 Preview opens at the latest activity in `less`; large sessions are limited to
 their latest 2,000 saved records. Press `/` to search, `n`/`N` to move between
@@ -423,6 +428,18 @@ Railmux also indexes resumable Claude Code and Codex sessions started outside
 Railmux, so existing conversations appear in the sidebar and resume the same
 way. Non-resumable one-off runs such as `codex exec` are filtered out.
 
+If the same Claude Code or Codex history root is shared across hosts, Railmux
+uses a provider-session lease to prevent two machines from resuming the same
+conversation concurrently. A remotely owned conversation remains in Sessions
+as **running on HOST**, but is not presented as a locally attachable Running
+entry; resume fails safely until that host's exact provider pane exits. The
+lease follows detached agents across Soft Quit and covers every known Codex
+rewind-lineage ID at resume; later rewinds retain a stable locked lineage
+anchor. Delete also checks the shared lease immediately before
+starting and refuses remotely owned history. The shared filesystem must provide
+cross-host POSIX advisory-lock semantics; mounts configured with local-only or
+disabled locking cannot provide this guarantee.
+
 ### Restarts and quitting
 
 Each opened agent runs in a detached tmux session, so switching sessions does

{railmux-0.4.0.dev15 → railmux-0.4.0.dev17}/README.md

@@ -127,7 +127,7 @@ for focus and layout limits.
 |--------|--------|
 | Left-click (non-running) | Preview session history in the Target pane |
 | Left-click (running) | Switch the Target pane to that session |
-| Wheel up over a live agent | Open its canonical current-branch history |
+| Wheel over a live agent | Scroll its live terminal history (native locally, Railmux-managed over `railmux ssh`) |
 | Double-click | Open/attach in the Target pane and move focus there |
 | Right-click | Context menu (Open, Preview, Info, Rename, Star, Copy title, Kill, Term, Delete) |
 
@@ -330,16 +330,21 @@ sessions move ahead of the other results.
 
 For a stopped session, left-click or press `␣` to view conversation history in
 the Target pane without starting or resuming the agent. For a running session,
-press `␣`, choose **Preview**, or wheel up over its live pane. Preview is
-read-only: it cannot send a message or change the session. User and assistant
-messages, tool calls, and abbreviated tool output are colour-coded, while
-internal context and encrypted reasoning are hidden. Codex rewind lineages and
-Claude Code `parentUuid` branches are projected onto the provider's current
-conversation: the retained prefix and replacement suffix remain visible, while
-the abandoned suffix is hidden. When Railmux observes a running Codex session
-advance after rewind or steering, it resets only the current terminal view
-before Codex redraws. Retained tmux scrollback is not erased, and managed
-history continues from the canonical rollout without its abandoned suffix.
+press `␣` or choose **Preview**. Preview is read-only: it cannot send a message
+or change the session. User and assistant messages, tool calls, and abbreviated
+tool output are colour-coded, while internal context and encrypted reasoning
+are hidden. Codex rewind lineages and Claude Code `parentUuid` branches are
+projected onto the provider's current conversation: the retained prefix and
+replacement suffix remain visible, while the abandoned suffix is hidden.
+
+Scrolling a live agent does not enter Preview. Direct `railmux` uses the
+terminal/tmux scrolling behavior; `railmux ssh` keeps its own bounded,
+per-pane history and normally preserves the live terminal's captured styling.
+When Railmux confirms that a running Codex session advanced after rewind or
+steering, it resets only the current terminal view before Codex redraws and
+invalidates that pane's SSH history generation. Retained tmux scrollback is not
+erased; the SSH history for that branched generation uses the canonical
+rollout so its abandoned suffix stays hidden.
 
 Preview opens at the latest activity in `less`; large sessions are limited to
 their latest 2,000 saved records. Press `/` to search, `n`/`N` to move between
@@ -380,6 +385,18 @@ Railmux also indexes resumable Claude Code and Codex sessions started outside
 Railmux, so existing conversations appear in the sidebar and resume the same
 way. Non-resumable one-off runs such as `codex exec` are filtered out.
 
+If the same Claude Code or Codex history root is shared across hosts, Railmux
+uses a provider-session lease to prevent two machines from resuming the same
+conversation concurrently. A remotely owned conversation remains in Sessions
+as **running on HOST**, but is not presented as a locally attachable Running
+entry; resume fails safely until that host's exact provider pane exits. The
+lease follows detached agents across Soft Quit and covers every known Codex
+rewind-lineage ID at resume; later rewinds retain a stable locked lineage
+anchor. Delete also checks the shared lease immediately before
+starting and refuses remotely owned history. The shared filesystem must provide
+cross-host POSIX advisory-lock semantics; mounts configured with local-only or
+disabled locking cannot provide this guarantee.
+
 ### Restarts and quitting
 
 Each opened agent runs in a detached tmux session, so switching sessions does

railmux-0.4.0.dev17/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.0.dev17"

{railmux-0.4.0.dev15 → railmux-0.4.0.dev17}/src/railmux/fast_display_client.py

@@ -202,6 +202,14 @@ def full_repaint(screen: AppliedScreen) -> AppliedScreen:
     )
 
 
+def selection_changed_rows(
+    before: tuple[SelectionSegment, ...],
+    after: tuple[SelectionSegment, ...],
+) -> set[int]:
+    """Rows that must be restored when one local highlight changes."""
+    return {row for row, _column, _text in (*before, *after)}
+
+
 def focus_in_frame_for_screen(screen: AppliedScreen | None) -> bytes | None:
     """Reassert focus only while the remote application requested events."""
     if screen is None or not screen.terminal_modes & TerminalMode.FOCUS_EVENTS:
@@ -637,6 +645,10 @@ class TerminalSurface:
         self.mouse_active = False
         self.mouse_suspended = False
         self.cursor_hidden = False
+        # Track the physical emulator cursor separately from the remote model.
+        # Re-sending DECSET/DECRST 25 on every 20 fps patch restarts the cursor
+        # animation in Windows Terminal and presents as a rapid flash.
+        self._painted_cursor_visible: bool | None = None
         self.terminal_modes = TerminalMode.NONE
         self.physical_size: os.terminal_size | None = None
         self._last_screen: AppliedScreen | None = None
@@ -694,6 +706,7 @@ class TerminalSurface:
         if interactive and not self.cursor_hidden:
             controls.append(b"\033[?25l")
             self.cursor_hidden = True
+            self._painted_cursor_visible = False
         if (
             interactive
             and self.mouse
@@ -793,6 +806,7 @@ class TerminalSurface:
         self.mouse_active = False
         self.mouse_suspended = False
         self.cursor_hidden = False
+        self._painted_cursor_visible = True
         self.interaction_active = True
 
     def show_local_status(
@@ -813,7 +827,8 @@ class TerminalSurface:
         self._local_status_level = level
         self._local_status_interruptible = interruptible
         self._local_status_expires_at = expires_at
-        rendered = [self._render_local_status()]
+        restore_cursor = self._last_screen is not None
+        rendered = [self._render_local_status(hide_cursor=not restore_cursor)]
         if self._last_screen is not None:
             projection_top, visible_height = self._projection(
                 self._last_screen.height
@@ -828,7 +843,7 @@ class TerminalSurface:
         self.stream.write(b"".join(rendered))
         self.stream.flush()
 
-    def _render_local_status(self) -> bytes:
+    def _render_local_status(self, *, hide_cursor: bool = True) -> bytes:
         """Render and locate the current local status-right replacement."""
         if self._local_status_text is None:
             self._local_status_bounds = None
@@ -841,10 +856,14 @@ class TerminalSurface:
             if self.physical_size is not None:
                 safe = safe[: self.physical_size.columns]
             self._local_status_bounds = (max(1, height), 1, max(1, len(safe)))
-            return (
+            rendered = (
                 f"\033[?7l\033[0m\033[{max(1, height)};1H\033[2K{safe}"
-                "\033[0m\033[?7h\033[?25l"
+                "\033[0m\033[?7h"
             ).encode("utf-8")
+            if hide_cursor:
+                rendered += b"\033[?25l"
+                self._painted_cursor_visible = False
+            return rendered
         width = screen.width
         if self.physical_size is not None:
             width = min(width, self.physical_size.columns)
@@ -862,8 +881,8 @@ class TerminalSurface:
             "warning": b"\033[1;38;5;220m",
             "error": b"\033[1;38;5;196m",
         }.get(level, b"\033[38;5;231m")
-        return b"".join(
-            (
+        rendered = b"".join(
+            [
                 b"\033[?7l\033[0m",
                 f"\033[{max(1, height)};{reserved + 1}H".encode(),
                 background,
@@ -871,9 +890,13 @@ class TerminalSurface:
                 b"\033[K",
                 f"\033[{max(1, height)};{column}H".encode(),
                 safe.encode("utf-8"),
-                b"\033[0m\033[?25l",
-            )
+                b"\033[0m",
+            ]
         )
+        if hide_cursor:
+            rendered += b"\033[?25l"
+            self._painted_cursor_visible = False
+        return rendered
 
     def clear_local_status(self) -> None:
         """Forget local feedback before restoring the authoritative screen."""
@@ -991,6 +1014,7 @@ class TerminalSurface:
             )
         self.stream.write(b"".join(rendered))
         self.stream.flush()
+        self._painted_cursor_visible = False
 
     def claude_history_prompt_choice(
         self,
@@ -1052,6 +1076,7 @@ class TerminalSurface:
             )
         self.stream.write(b"".join(rendered))
         self.stream.flush()
+        self._painted_cursor_visible = False
 
     def path_open_prompt_choice(
         self,
@@ -1108,6 +1133,7 @@ class TerminalSurface:
         # scroll the alternate screen.
         self.stream.write(b"\033[0m\033[?7h\033[?25l")
         self.stream.flush()
+        self._painted_cursor_visible = False
 
     @staticmethod
     def _cursor_is_covered(
@@ -1171,38 +1197,37 @@ class TerminalSurface:
                 )
             )
 
-    @classmethod
     def _append_cursor(
-        cls,
+        self,
         rendered: list[bytes],
         screen: AppliedScreen,
         overlays: tuple[tuple[HistorySnapshot, tuple[bytes, ...]], ...],
         *,
         projection_top: int = 0,
         visible_height: int | None = None,
+        force_visibility: bool = False,
     ) -> None:
         cursor_in_projection = (
             visible_height is None
             or projection_top <= screen.cursor_y < projection_top + visible_height
         )
-        rendered.extend(
-            (
-                b"\033[0m\033[?7h",
-                (
-                    f"\033[{screen.cursor_y - projection_top + 1};"
-                    f"{screen.cursor_x + 1}H"
-                ).encode()
-                if cursor_in_projection
-                else b"\033[1;1H",
-                (
-                    b"\033[?25h"
-                    if screen.cursor_visible
-                    and cursor_in_projection
-                    and not cls._cursor_is_covered(screen, overlays)
-                    else b"\033[?25l"
-                ),
-            )
+        visible = bool(
+            screen.cursor_visible
+            and cursor_in_projection
+            and not self._cursor_is_covered(screen, overlays)
         )
+        rendered.extend((
+            b"\033[0m\033[?7h",
+            (
+                f"\033[{screen.cursor_y - projection_top + 1};"
+                f"{screen.cursor_x + 1}H"
+            ).encode()
+            if cursor_in_projection
+            else b"\033[1;1H",
+        ))
+        if force_visibility or self._painted_cursor_visible is not visible:
+            rendered.append(b"\033[?25h" if visible else b"\033[?25l")
+            self._painted_cursor_visible = visible
 
     def paint(
         self,
@@ -1250,7 +1275,7 @@ class TerminalSurface:
             visible_height=visible_height,
         )
         if self._local_status_text is not None:
-            rendered.append(self._render_local_status())
+            rendered.append(self._render_local_status(hide_cursor=False))
         # Status and selection painting move and may temporarily hide the
         # terminal cursor.  Restoring the authoritative cursor must therefore
         # be the final operation in every complete paint.
@@ -1289,7 +1314,61 @@ class TerminalSurface:
             visible_height=visible_height,
         )
         if self._local_status_text is not None:
-            rendered.append(self._render_local_status())
+            rendered.append(self._render_local_status(hide_cursor=False))
+        self._append_cursor(
+            rendered,
+            screen,
+            overlays,
+            projection_top=projection_top,
+            visible_height=visible_height,
+        )
+        self.stream.write(b"".join(rendered))
+        self.stream.flush()
+
+    def paint_changed_rows(
+        self,
+        screen: AppliedScreen,
+        overlays: tuple[tuple[HistorySnapshot, tuple[bytes, ...]], ...],
+        selection: tuple[SelectionSegment, ...],
+        changed_rows: set[int] | frozenset[int],
+    ) -> None:
+        """Restore and repaint only rows touched by a local highlight.
+
+        Hover, drag selection, and click flash are local overlays. Clearing the
+        whole alternate screen for them is both unnecessary and visibly flashes
+        in Windows Terminal. Restore each affected row from the authoritative
+        live frame, then layer frozen history and the new highlight back on it.
+        """
+        self.start()
+        self._last_screen = screen
+        self._last_overlays = overlays
+        projection_top, visible_height = self._projection(screen.height)
+        rows = frozenset(
+            row for row in changed_rows
+            if projection_top <= row < projection_top + visible_height
+        )
+        rendered: list[bytes] = [b"\033[?7l"]
+        for row in sorted(rows):
+            rendered.extend((
+                f"\033[{row - projection_top + 1};1H".encode(),
+                b"\033[2K",
+                screen.rows[row],
+            ))
+        self._append_overlay_rows(
+            rendered,
+            overlays,
+            projection_top=projection_top,
+            visible_height=visible_height,
+            changed_rows=rows,
+        )
+        self._append_selection_segments(
+            rendered,
+            selection,
+            projection_top=projection_top,
+            visible_height=visible_height,
+        )
+        if self._local_status_text is not None and screen.height - 1 in rows:
+            rendered.append(self._render_local_status(hide_cursor=False))
         self._append_cursor(
             rendered,
             screen,
@@ -1312,6 +1391,7 @@ class TerminalSurface:
             self._last_overlays,
             projection_top=projection_top,
             visible_height=visible_height,
+            force_visibility=True,
         )
         self.stream.write(b"".join(rendered))
         self.stream.flush()
@@ -1333,6 +1413,7 @@ class TerminalSurface:
         self.mouse_active = False
         self.mouse_suspended = False
         self.cursor_hidden = False
+        self._painted_cursor_visible = None
         self.clear_local_status()
         self._last_screen = None
         self._reconnect_status_screen = None
@@ -2627,11 +2708,14 @@ def run(args: argparse.Namespace) -> int:
                     focused_pane_id=focused_pane_id,
                 )
             )
+            before = selection.segments()
             if selection.hover(hover_event, source) and latest_screen is not None:
-                surface.paint(
-                    full_repaint(latest_screen),
+                after = selection.segments()
+                surface.paint_changed_rows(
+                    latest_screen,
                     history.overlays(),
-                    selection.segments(),
+                    after,
+                    selection_changed_rows(before, after),
                 )
             return
         if path_open_prompt is not None:
@@ -2751,6 +2835,7 @@ def run(args: argparse.Namespace) -> int:
             # one persistent choice is still being confirmed.
             return
         if isinstance(part, SgrMouseEvent):
+            selection_before = selection.segments()
             displayed_height = (
                 latest_screen.height
                 if latest_screen is not None
@@ -2807,10 +2892,12 @@ def run(args: argparse.Namespace) -> int:
             if selection.capturing or not selection.active:
                 selection_clear_at = None
             if selection_action.repaint and latest_screen is not None:
-                surface.paint(
-                    full_repaint(latest_screen),
+                selection_after = selection.segments()
+                surface.paint_changed_rows(
+                    latest_screen,
                     history.overlays(),
-                    selection.segments(),
+                    selection_after,
+                    selection_changed_rows(selection_before, selection_after),
                 )
             for replay_event in selection_action.replay_events:
                 if not claim_batched_wheel(replay_event, handled_wheels):
@@ -2835,6 +2922,7 @@ def run(args: argparse.Namespace) -> int:
                 selection_clear_at = time.monotonic() + _SELECTION_HIGHLIGHT_SECONDS
             if selection_action.open_target is not None:
                 target = selection_action.open_target
+                flash_before = selection.segments()
                 if (
                     selection.flash(
                         target,
@@ -2843,10 +2931,12 @@ def run(args: argparse.Namespace) -> int:
                     )
                     and latest_screen is not None
                 ):
-                    surface.paint(
-                        full_repaint(latest_screen),
+                    flash_after = selection.segments()
+                    surface.paint_changed_rows(
+                        latest_screen,
                         history.overlays(),
-                        selection.segments(),
+                        flash_after,
+                        selection_changed_rows(flash_before, flash_after),
                     )
                 if target.kind == "url":
                     show_open_result(local_open.open_url(target.value))
@@ -3301,6 +3391,7 @@ def run(args: argparse.Namespace) -> int:
                 restore_local_status = surface.expire_local_status(now) or (
                     history_info_until is not None and now >= history_info_until
                 )
+                timed_selection_before = selection.segments()
                 clear_selection = (
                     selection_clear_at is not None and now >= selection_clear_at
                 )
@@ -3310,13 +3401,24 @@ def run(args: argparse.Namespace) -> int:
                         selection.cancel()
                     if restore_local_status:
                         surface.clear_local_status()
-                    if latest_screen is not None:
+                    timed_selection_after = selection.segments()
+                    if latest_screen is not None and restore_local_status:
                         surface.paint(
                             full_repaint(latest_screen),
                             history.overlays(),
-                            selection.segments(),
+                            timed_selection_after,
                         )
                         redraw_local_prompt()
+                    elif latest_screen is not None:
+                        surface.paint_changed_rows(
+                            latest_screen,
+                            history.overlays(),
+                            timed_selection_after,
+                            selection_changed_rows(
+                                timed_selection_before,
+                                timed_selection_after,
+                            ),
+                        )
                     if restore_local_status:
                         history_info_until = None
                     if clear_selection:

{railmux-0.4.0.dev15 → railmux-0.4.0.dev17}/src/railmux/fast_display_history.py

@@ -287,15 +287,17 @@ class LocalHistoryView:
                 # intermediate output above the current screen.
                 lines = incoming.lines
             else:
-                # A full-screen TUI redraw can leave no trustworthy text
-                # anchor. Preserve the known history and replace only the
-                # mutable live viewport. Appending every unaligned 300-line
-                # prefetch would duplicate a full screen every three seconds.
-                live_count = min(incoming.height, len(incoming.lines))
-                retained = previous.lines[
-                    : -min(previous.height, len(previous.lines))
-                ]
-                lines = retained + incoming.lines[-live_count:]
+                # 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
         else:
             start = min(0, delta)
             incoming_end = delta + len(incoming.lines)

{railmux-0.4.0.dev15 → railmux-0.4.0.dev17}/src/railmux/fast_display_server.py

@@ -406,6 +406,7 @@ class _PaneGeometry:
     transcript_provider: str | None = None
     claude_history_policy: str = "ask"
     history_generation: int = 0
+    canonical_history: bool = False
 
 
 @dataclass(frozen=True)
@@ -432,11 +433,14 @@ _HISTORY_GENERATION_RE = re.compile(
 
 def _history_generation(marker: str) -> int:
     """Map one validated provider UUID to a bounded opaque wire epoch."""
+    generation_marker = marker
+    if marker.startswith(tmux_ctl.RAILMUX_CANONICAL_HISTORY_PREFIX):
+        marker = marker[len(tmux_ctl.RAILMUX_CANONICAL_HISTORY_PREFIX):]
     if not _HISTORY_GENERATION_RE.fullmatch(marker):
         return 0
     return int.from_bytes(
         hashlib.blake2b(
-            marker.lower().encode("ascii"),
+            generation_marker.lower().encode("ascii"),
             digest_size=8,
             person=b"railmux-history",
         ).digest(),
@@ -937,6 +941,15 @@ def _list_agent_panes(
             if opened is not None:
                 transcript_locator = opened[0]
                 os.close(opened[1])
+        history_marker = fields[15]
+        canonical_history = bool(
+            transcript_backed
+            and transcript_locator is not None
+            and history_marker == (
+                f"{tmux_ctl.RAILMUX_CANONICAL_HISTORY_PREFIX}"
+                f"{transcript_locator.session_id}"
+            )
+        )
         rows.append(
             (
                 fields[2] == "1",
@@ -960,7 +973,8 @@ def _list_agent_panes(
                         else None
                     ),
                     claude_history_policy=claude_history_policy,
-                    history_generation=_history_generation(fields[15]),
+                    history_generation=_history_generation(history_marker),
+                    canonical_history=canonical_history,
                 ),
             )
         )
@@ -1347,7 +1361,7 @@ def _capture_pane_history(
         pane.transcript_backed
         and pane.transcript_source
         and (
-            transcript_provider == "codex"
+            (transcript_provider == "codex" and pane.canonical_history)
             or (
                 transcript_provider == "claude"
                 and pane.claude_history_policy == "local"

{railmux-0.4.0.dev15 → railmux-0.4.0.dev17}/src/railmux/models.py

@@ -75,6 +75,9 @@ class SessionMeta:
     # conversation without changing the provider-owned UUID used for resume.
     # Always None for Claude sessions and older Codex rollouts.
     forked_from_id: str | None = None
+    # A Railmux lease observed in the same shared provider history root. This
+    # is a read-time UI overlay, never provider transcript metadata.
+    remote_owner: str | None = None
 
     @property
     def display_title(self) -> str: