railmux 0.4.1.dev5__tar.gz → 0.4.1.dev6__tar.gz

{railmux-0.4.1.dev5/src/railmux.egg-info → railmux-0.4.1.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.1.dev5
+Version: 0.4.1.dev6
 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.4.1.dev6/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.1.dev6"

{railmux-0.4.1.dev5 → railmux-0.4.1.dev6}/src/railmux/fast_display_input.py

@@ -22,6 +22,9 @@ from railmux.fast_display_protocol import (
 
 _SGR_MOUSE_PREFIX = b"\x1b[<"
 _SGR_STYLE_RE = re.compile(rb"\x1b\[[0-9;]*m")
+_OSC8_LINK_RE = re.compile(
+    rb"\x1b\]8;[^;\x07\x1b]*;([^\x07\x1b]*)(?:\x07|\x1b\\)"
+)
 _PAGE_UP = b"\x1b[5~"
 _PAGE_DOWN = b"\x1b[6~"
 _BRACKETED_PASTE_BEGIN = b"\x1b[200~"
@@ -505,27 +508,62 @@ def _display_width(character: str) -> int:
     return max(0, pyte.screens.wcwidth(character))
 
 
-def _plain_display_cells(line: bytes, width: int) -> tuple[str | None, ...]:
-    """Decode one server-rendered SGR row into bounded display cells."""
-    plain = _SGR_STYLE_RE.sub(b"", line).decode("utf-8", errors="replace")
+def _validated_osc8_url(value: bytes) -> str | None:
+    if not value or len(value) > 8192:
+        return None
+    try:
+        decoded = value.decode("utf-8")
+        parsed = urlsplit(decoded)
+        hostname = parsed.hostname
+    except (UnicodeDecodeError, ValueError):
+        return None
+    if (
+        parsed.scheme.lower() not in ("http", "https")
+        or hostname is None
+        or any(ord(character) < 0x20 or character == "\x7f" for character in decoded)
+    ):
+        return None
+    return decoded
+
+
+def _plain_display_row(
+    line: bytes,
+    width: int,
+) -> tuple[tuple[str | None, ...], tuple[str | None, ...]]:
+    """Decode one rendered row and retain bounded OSC 8 targets per cell."""
     cells: list[str | None] = [" "] * width
+    hyperlinks: list[str | None] = [None] * width
     column = 0
-    for character in plain:
-        cell_width = _display_width(character)
-        if cell_width == 0:
-            previous = column - 1
-            while previous >= 0 and cells[previous] is None:
-                previous -= 1
-            if previous >= 0:
-                cells[previous] = (cells[previous] or "") + character
-            continue
-        if column >= width or column + cell_width > width:
-            break
-        cells[column] = character
-        for continuation in range(1, cell_width):
-            cells[column + continuation] = None
-        column += cell_width
-    return tuple(cells)
+    active_hyperlink: str | None = None
+
+    def append_visible(data: bytes) -> None:
+        nonlocal column
+        plain = _SGR_STYLE_RE.sub(b"", data).decode("utf-8", errors="replace")
+        for character in plain:
+            cell_width = _display_width(character)
+            if cell_width == 0:
+                previous = column - 1
+                while previous >= 0 and cells[previous] is None:
+                    previous -= 1
+                if previous >= 0:
+                    cells[previous] = (cells[previous] or "") + character
+                continue
+            if column >= width or column + cell_width > width:
+                return
+            cells[column] = character
+            hyperlinks[column] = active_hyperlink
+            for continuation in range(1, cell_width):
+                cells[column + continuation] = None
+                hyperlinks[column + continuation] = active_hyperlink
+            column += cell_width
+
+    offset = 0
+    for match in _OSC8_LINK_RE.finditer(line):
+        append_visible(line[offset : match.start()])
+        active_hyperlink = _validated_osc8_url(match.group(1))
+        offset = match.end()
+    append_visible(line[offset:])
+    return tuple(cells), tuple(hyperlinks)
 
 
 _CLICK_TOKEN_RE = re.compile(r"""[^\s<>"'`]+""")
@@ -719,23 +757,97 @@ def click_target_at(
     return None
 
 
-def _pane_cells(
+def _pane_rows(
     source: SelectionSource,
     *,
     start: int = 0,
     end: int | None = None,
-) -> tuple[tuple[str | None, ...], ...]:
-    """Decode pane-local cells from either full-screen or history rows."""
+) -> tuple[
+    tuple[tuple[str | None, ...], ...],
+    tuple[tuple[str | None, ...], ...],
+]:
+    """Decode pane-local cells and OSC 8 targets in one bounded pass."""
     route = source.route
     if end is None:
         end = route.height
     decode_width = source.row_x_offset + route.width
-    decoded: list[tuple[str | None, ...]] = []
+    decoded_cells: list[tuple[str | None, ...]] = []
+    decoded_hyperlinks: list[tuple[str | None, ...]] = []
     for index in range(start, min(end, route.height)):
         line = source.rows[index] if index < len(source.rows) else b""
-        cells = _plain_display_cells(line, decode_width)
-        decoded.append(cells[source.row_x_offset : source.row_x_offset + route.width])
-    return tuple(decoded)
+        cells, hyperlinks = _plain_display_row(line, decode_width)
+        span = slice(source.row_x_offset, source.row_x_offset + route.width)
+        decoded_cells.append(cells[span])
+        decoded_hyperlinks.append(hyperlinks[span])
+    return tuple(decoded_cells), tuple(decoded_hyperlinks)
+
+
+def _pane_cells(
+    source: SelectionSource,
+    *,
+    start: int = 0,
+    end: int | None = None,
+) -> tuple[tuple[str | None, ...], ...]:
+    """Decode pane-local cells from either full-screen or history rows."""
+    return _pane_rows(source, start=start, end=end)[0]
+
+
+def _osc8_target(
+    rows: tuple[tuple[str | None, ...], ...],
+    hyperlinks: tuple[tuple[str | None, ...], ...],
+    row: int,
+    column: int,
+    *,
+    route: HistorySnapshot,
+) -> ClickTarget | None:
+    """Resolve one exact OSC 8 target without reconstructing its label."""
+    if not (0 <= row < len(rows) and 0 <= row < len(hyperlinks)):
+        return None
+    if not 0 <= column < len(hyperlinks[row]):
+        return None
+    value = hyperlinks[row][column]
+    if value is None:
+        return None
+
+    segments: list[SelectionSegment] = []
+    first = row
+    while first > 0 and value in hyperlinks[first - 1]:
+        first -= 1
+    last = row
+    while last + 1 < len(hyperlinks) and value in hyperlinks[last + 1]:
+        last += 1
+    for row_index in range(first, last + 1):
+        link_row = hyperlinks[row_index]
+        cell_row = rows[row_index]
+        run_start: int | None = None
+        for cell_index in range(len(link_row) + 1):
+            linked = cell_index < len(link_row) and link_row[cell_index] == value
+            if linked and run_start is None:
+                run_start = cell_index
+            if not linked and run_start is not None:
+                text = "".join(
+                    cell or "" for cell in cell_row[run_start:cell_index]
+                ).encode("utf-8")
+                if text:
+                    segments.append(
+                        (
+                            route.y + row_index,
+                            route.x + run_start,
+                            text,
+                        )
+                    )
+                run_start = None
+    if not segments:
+        return None
+    return ClickTarget(
+        "url",
+        value,
+        route.pane_id or "",
+        highlight_row=segments[0][0],
+        highlight_column=segments[0][1],
+        highlight_text=segments[0][2],
+        highlight_segments=tuple(segments),
+    )
 
 
 def _rows_are_wrapped(
@@ -1124,10 +1236,14 @@ def _target_in_rows(
     column: int,
     *,
     route: HistorySnapshot,
+    hyperlinks: tuple[tuple[str | None, ...], ...] = (),
 ) -> ClickTarget | None:
     """Resolve a semantic target across one bounded visual-wrap chain."""
     if not 0 <= row < len(rows) or route.width <= 0:
         return None
+    exact = _osc8_target(rows, hyperlinks, row, column, route=route)
+    if exact is not None:
+        return exact
     decorated = _decorated_tool_target(
         rows,
         row,
@@ -1200,6 +1316,7 @@ class LocalTextSelection:
         self._press: SgrMouseEvent | None = None
         self._route: HistorySnapshot | None = None
         self._rows: tuple[tuple[str | None, ...], ...] = ()
+        self._hyperlinks: tuple[tuple[str | None, ...], ...] = ()
         self._anchor: tuple[int, int] | None = None
         self._head: tuple[int, int] | None = None
         self._active = False
@@ -1221,6 +1338,7 @@ class LocalTextSelection:
         self._press = None
         self._route = None
         self._rows = ()
+        self._hyperlinks = ()
         self._anchor = None
         self._head = None
         self._active = False
@@ -1240,8 +1358,9 @@ class LocalTextSelection:
             return None
         start = max(0, row - 7)
         end = min(source.route.height, row + 8)
+        rows, hyperlinks = _pane_rows(source, start=start, end=end)
         return _target_in_rows(
-            _pane_cells(source, start=start, end=end),
+            rows,
             row - start,
             column,
             route=replace(
@@ -1249,6 +1368,7 @@ class LocalTextSelection:
                 y=source.route.y + start,
                 height=end - start,
             ),
+            hyperlinks=hyperlinks,
         )
 
     def hover(
@@ -1352,7 +1472,7 @@ class LocalTextSelection:
         route = source.route
         self._press = event
         self._route = route
-        self._rows = _pane_cells(source)
+        self._rows, self._hyperlinks = _pane_rows(source)
         self._anchor = self._point(event, route)
         self._head = self._anchor
         self._active = False
@@ -1385,6 +1505,7 @@ class LocalTextSelection:
                             self._anchor[1],
                             self._anchor[0],
                             route=self._route,
+                            hyperlinks=self._hyperlinks,
                         )
                         if (
                             self._semantic_open

{railmux-0.4.1.dev5 → railmux-0.4.1.dev6}/src/railmux/fast_display_server.py

@@ -80,6 +80,7 @@ from railmux.fast_display_protocol import (
 )
 from railmux.fast_display_history import HistoryCaptureJob, HistoryCaptureWorker
 from railmux.terminal_screen import (
+    HyperlinkTrackingStream,
     Osc52ClipboardDecoder as _Osc52ClipboardDecoder,
     ScreenState as _ScreenState,
     build_screen_update,
@@ -1226,7 +1227,7 @@ def _render_history_lines(
     result independently paintable for the local history overlay.
     """
     screen = pyte.Screen(width, 1)
-    stream = pyte.ByteStream(screen)
+    stream = HyperlinkTrackingStream(screen, pyte.ByteStream(screen))
     rendered: list[bytes] = []
     for line in lines:
         screen.buffer[0].clear()
@@ -2206,7 +2207,7 @@ def _serve_attached(
     master_fd: int,
 ) -> int:
     screen = pyte.DiffScreen(width, height)
-    stream = pyte.ByteStream(screen)
+    stream = HyperlinkTrackingStream(screen, pyte.ByteStream(screen))
     input_decoder = InputFrameDecoder()
     stdin_fd = sys.stdin.buffer.fileno()
     stdout_fd = sys.stdout.buffer.fileno()

{railmux-0.4.1.dev5 → railmux-0.4.1.dev6}/src/railmux/terminal_screen.py

@@ -14,6 +14,8 @@ import re
 from dataclasses import dataclass
 from functools import lru_cache
 from types import SimpleNamespace
+from typing import NamedTuple
+from urllib.parse import urlsplit
 
 from railmux.fast_display_protocol import (
     MAX_CLIPBOARD_BYTES,
@@ -65,6 +67,121 @@ _ANSI_BG = {
 }
 _OSC52_PREFIX = b"\033]52;"
 _OSC52_MAX_ENCODED = ((MAX_CLIPBOARD_BYTES + 2) // 3) * 4
+_OSC8_PREFIX = b"\033]8;"
+_OSC8_MAX_BYTES = 16 * 1024
+_MAX_SCREEN_HYPERLINKS = 256
+
+
+class _HyperlinkChar(NamedTuple):
+    """A pyte-compatible cell with one bounded OSC 8 target."""
+
+    data: str
+    fg: str = "default"
+    bg: str = "default"
+    bold: bool = False
+    italics: bool = False
+    underscore: bool = False
+    strikethrough: bool = False
+    reverse: bool = False
+    blink: bool = False
+    hyperlink: str | None = None
+
+
+def _hyperlink_char(char: object, hyperlink: str | None) -> _HyperlinkChar:
+    return _HyperlinkChar(
+        data=char.data,
+        fg=char.fg,
+        bg=char.bg,
+        bold=char.bold,
+        italics=char.italics,
+        underscore=char.underscore,
+        strikethrough=char.strikethrough,
+        reverse=char.reverse,
+        blink=char.blink,
+        hyperlink=hyperlink,
+    )
+
+
+def _safe_hyperlink(value: bytes) -> str | None:
+    if not value or len(value) > 8192:
+        return None
+    try:
+        decoded = value.decode("utf-8")
+    except UnicodeDecodeError:
+        return None
+    if any(ord(character) < 0x20 or character == "\x7f" for character in decoded):
+        return None
+    try:
+        parsed = urlsplit(decoded)
+        hostname = parsed.hostname
+    except ValueError:
+        return None
+    if parsed.scheme.lower() not in ("http", "https") or hostname is None:
+        return None
+    return decoded
+
+
+class HyperlinkTrackingStream:
+    """Preserve bounded HTTP(S) OSC 8 targets in pyte screen cells.
+
+    pyte intentionally ignores OSC 8.  Railmux needs the target independently
+    from its often-wrapped display label, so this wrapper consumes only OSC 8,
+    updates the extended screen's cell attribute, and passes every other byte
+    through unchanged.  The parser is incremental and bounded because PTY
+    reads may split either terminator.
+    """
+
+    def __init__(self, screen: object, stream: object) -> None:
+        self.screen = screen
+        self.stream = stream
+        self._buffer = bytearray()
+
+    def _feed_visible(self, data: bytes) -> None:
+        if data:
+            self.stream.feed(data)
+
+    def feed(self, data: bytes) -> None:
+        if not data:
+            return
+        self._buffer.extend(data)
+        while self._buffer:
+            start = self._buffer.find(_OSC8_PREFIX)
+            if start < 0:
+                keep = 0
+                maximum = min(len(self._buffer), len(_OSC8_PREFIX) - 1)
+                for length in range(maximum, 0, -1):
+                    if _OSC8_PREFIX.startswith(self._buffer[-length:]):
+                        keep = length
+                        break
+                visible_end = len(self._buffer) - keep
+                self._feed_visible(bytes(self._buffer[:visible_end]))
+                del self._buffer[:visible_end]
+                return
+            if start:
+                self._feed_visible(bytes(self._buffer[:start]))
+                del self._buffer[:start]
+            bel = self._buffer.find(b"\007", len(_OSC8_PREFIX))
+            st = self._buffer.find(b"\033\\", len(_OSC8_PREFIX))
+            endings = tuple(
+                (position, length)
+                for position, length in ((bel, 1), (st, 2))
+                if position >= 0
+            )
+            if not endings:
+                if len(self._buffer) <= _OSC8_MAX_BYTES:
+                    return
+                # An unterminated lookalike is ordinary terminal output. Feed
+                # one byte and resume scanning without retaining an unbounded
+                # attacker-controlled prefix.
+                self._feed_visible(bytes(self._buffer[:1]))
+                del self._buffer[:1]
+                continue
+            end, terminator_length = min(endings)
+            body = bytes(self._buffer[len(_OSC8_PREFIX) : end])
+            del self._buffer[: end + terminator_length]
+            _params, separator, target = body.partition(b";")
+            hyperlink = _safe_hyperlink(target) if separator else None
+            self.screen.set_hyperlink(hyperlink)
 
 
 class Osc52ClipboardDecoder:
@@ -123,9 +240,29 @@ class _ExtendedScreenMixin:
     _last_graphic_character = ""
     _character_width = staticmethod(lambda _character: 1)
 
+    @property
+    def default_char(self) -> _HyperlinkChar:
+        return _hyperlink_char(super().default_char, None)
+
     def reset(self) -> None:
         self._last_graphic_character = ""
+        self._active_hyperlink: str | None = None
+        self._known_hyperlinks: dict[str, str] = {}
         super().reset()
+        self.cursor.attrs = _hyperlink_char(self.cursor.attrs, None)
+
+    def set_hyperlink(self, hyperlink: str | None) -> None:
+        if hyperlink is not None:
+            known = self._known_hyperlinks.get(hyperlink)
+            if known is None:
+                if len(self._known_hyperlinks) >= _MAX_SCREEN_HYPERLINKS:
+                    hyperlink = None
+                else:
+                    self._known_hyperlinks[hyperlink] = hyperlink
+            else:
+                hyperlink = known
+        self._active_hyperlink = hyperlink
+        self.cursor.attrs = _hyperlink_char(self.cursor.attrs, hyperlink)
 
     def draw(self, data: str) -> None:
         super().draw(data)
@@ -174,6 +311,10 @@ class _ExtendedScreenMixin:
     def select_graphic_rendition(self, *attrs: int) -> None:
         """Retain 256-colour indices instead of baking in pyte's palette."""
         super().select_graphic_rendition(*attrs)
+        self.cursor.attrs = _hyperlink_char(
+            self.cursor.attrs,
+            self._active_hyperlink,
+        )
         values = list(attrs)
         indexed: dict[str, int] = {}
         index = 0
@@ -209,6 +350,14 @@ class _ExtendedScreenMixin:
                 **{key: f"ansi256:{colour}" for key, colour in indexed.items()}
             )
 
+    def restore_cursor(self) -> None:
+        super().restore_cursor()
+        # OSC 8 state is not part of DECSC/DECRC cursor attributes.
+        self.cursor.attrs = _hyperlink_char(
+            self.cursor.attrs,
+            self._active_hyperlink,
+        )
+
 
 @lru_cache(maxsize=4)
 def _build_extended_pyte(pyte: object) -> object:
@@ -333,6 +482,7 @@ def render_rows(screen: object) -> tuple[bytes, ...]:
     for row_index in range(screen.lines):
         rendered = [b"\033[0m"]
         previous_style: tuple[object, ...] | None = None
+        previous_hyperlink: str | None = None
         row = screen.buffer[row_index]
         rendered_columns = _last_rendered_column(row, screen.columns)
         continuation_cells = 0
@@ -346,6 +496,17 @@ def render_rows(screen: object) -> tuple[bytes, ...]:
                 continuation_cells = 0
                 continuation_data = ""
             char = row[column]
+            hyperlink = getattr(char, "hyperlink", None)
+            if hyperlink != previous_hyperlink:
+                if previous_hyperlink is not None:
+                    rendered.append(b"\033]8;;\033\\")
+                if hyperlink is not None:
+                    rendered.append(
+                        b"\033]8;;"
+                        + hyperlink.encode("utf-8", errors="strict")
+                        + b"\033\\"
+                    )
+                previous_hyperlink = hyperlink
             style = _style_key(char)
             if style != previous_style:
                 rendered.append(_style(char))
@@ -366,6 +527,8 @@ def render_rows(screen: object) -> tuple[bytes, ...]:
                 )
                 continuation_cells = max(0, cell_width - 1)
                 continuation_data = char.data
+        if previous_hyperlink is not None:
+            rendered.append(b"\033]8;;\033\\")
         rendered.append(b"\033[0m")
         rendered_rows.append(b"".join(rendered))
     return tuple(rendered_rows)
@@ -465,7 +628,10 @@ class ScreenProducer:
         self.width = width
         self.height = height
         self.screen = self.pyte.DiffScreen(width, height)
-        self.stream = self.pyte.ByteStream(self.screen)
+        self.stream = HyperlinkTrackingStream(
+            self.screen,
+            self.pyte.ByteStream(self.screen),
+        )
         self._clipboard = Osc52ClipboardDecoder()
         self._clipboard_ready: list[bytes] = []
         self.delivered: ScreenState | None = None

{railmux-0.4.1.dev5 → railmux-0.4.1.dev6/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.1.dev5
+Version: 0.4.1.dev6
 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.4.1.dev5 → railmux-0.4.1.dev6}/tests/test_fast_display_selection.py

@@ -717,6 +717,66 @@ def test_local_text_selection_joins_url_across_codex_ran_decoration():
         assert action.open_target.value == expected
 
 
+def test_local_text_selection_uses_exact_osc8_target_across_table_rows():
+    target = "https://jirasw.nvidia.com/browse/TRT-28431"
+
+    def linked(label: str) -> bytes:
+        return (
+            b"\033]8;;"
+            + target.encode()
+            + b"\033\\"
+            + label.encode()
+            + b"\033]8;;\033\\"
+        )
+
+    visible = ("TRT-28431", "https://", "jirasw.nvidia.co", "m/browse/TRT-28431")
+    width = max(len(value) for value in visible)
+    route = HistorySnapshot(1, "%8", 7, 3, width, len(visible))
+    source = SelectionSource(
+        route,
+        tuple(linked(value) for value in visible),
+        0,
+    )
+
+    for row, label in enumerate(visible):
+        selection = LocalTextSelection()
+        event_row = route.y + row + 1
+        selection.pointer_event(
+            SgrMouseEvent(b"down", 0, route.x + 2, event_row, True),
+            source,
+        )
+        action = selection.pointer_event(
+            SgrMouseEvent(b"up", 0, route.x + 2, event_row, False),
+            source,
+        )
+        assert action.open_target is not None, label
+        assert action.open_target.kind == "url"
+        assert action.open_target.value == target
+        assert action.open_target.highlight_segments == tuple(
+            (route.y + index, route.x, value.encode())
+            for index, value in enumerate(visible)
+        )
+
+
+def test_local_text_selection_does_not_trust_non_http_osc8_target():
+    route = HistorySnapshot(1, "%8", 0, 0, 24, 1)
+    source = SelectionSource(
+        route,
+        (b"\033]8;;file:///tmp/report\033\\open report\033]8;;\033\\",),
+        0,
+    )
+    selection = LocalTextSelection()
+
+    selection.pointer_event(SgrMouseEvent(b"down", 0, 2, 1, True), source)
+    action = selection.pointer_event(
+        SgrMouseEvent(b"up", 0, 2, 1, False),
+        source,
+    )
+
+    assert action.open_target is None
+    assert action.replay_events
+
+
 def test_local_text_selection_joins_path_across_codex_ran_decoration():
     first = "• Ran /tmp/railmux-published-0.4.1.dev1-"
     second = "  │ 20260816/bin/pip --isolated"

{railmux-0.4.1.dev5 → railmux-0.4.1.dev6}/tests/test_fast_display_server.py

@@ -1900,6 +1900,70 @@ def test_server_renderer_keeps_visible_styled_trailing_blanks():
     assert b";41m   " in rendered
 
 
+def test_terminal_model_preserves_fragmented_http_osc8_targets_in_rows():
+    pyte = pytest.importorskip("pyte")
+    terminal = fast_display_server._extended_pyte(pyte)
+    screen = terminal.Screen(24, 2)
+    stream = fast_display_server.HyperlinkTrackingStream(
+        screen,
+        terminal.ByteStream(screen),
+    )
+    target = b"https://jirasw.nvidia.com/browse/TRT-28431"
+
+    for chunk in (
+        b"\033]8;i",
+        b"d=issue;" + target[:20],
+        target[20:] + b"\033",
+        b"\\TRT-28431\033]8;;\033\\",
+    ):
+        stream.feed(chunk)
+
+    rendered = render_rows(screen)[0]
+    assert b"TRT-28431" in rendered
+    assert b"\033]8;;" + target + b"\033\\" in rendered
+    assert screen.buffer[0][0].hyperlink == target.decode()
+    assert screen.buffer[0][8].hyperlink == target.decode()
+    assert screen.buffer[0][9].hyperlink is None
+
+
+def test_terminal_model_drops_unsafe_or_stale_osc8_targets():
+    pyte = pytest.importorskip("pyte")
+    terminal = fast_display_server._extended_pyte(pyte)
+    screen = terminal.Screen(8, 1)
+    stream = fast_display_server.HyperlinkTrackingStream(
+        screen,
+        terminal.ByteStream(screen),
+    )
+
+    stream.feed(b"\033]8;;https://safe.test\007ok\033]8;;\007")
+    stream.feed(b"\033[1Gplain")
+    stream.feed(b"\033]8;;file:///tmp/nope\007x\033]8;;\007")
+
+    rendered = render_rows(screen)[0]
+    assert b"https://safe.test" not in rendered
+    assert b"file:///tmp/nope" not in rendered
+    assert all(screen.buffer[0][column].hyperlink is None for column in range(6))
+
+
+def test_terminal_model_bounds_distinct_live_osc8_targets():
+    pyte = pytest.importorskip("pyte")
+    terminal = fast_display_server._extended_pyte(pyte)
+    screen = terminal.Screen(300, 1)
+    stream = fast_display_server.HyperlinkTrackingStream(
+        screen,
+        terminal.ByteStream(screen),
+    )
+
+    for index in range(257):
+        stream.feed(
+            f"\033]8;;https://example.test/{index}\007x\033]8;;\007".encode()
+        )
+
+    assert len(screen._known_hyperlinks) == 256
+    assert screen.buffer[0][255].hyperlink == "https://example.test/255"
+    assert screen.buffer[0][256].hyperlink is None
+
+
 def test_server_renderer_collapses_reported_repeated_cjk_physical_cells():
     text = "基本通了，但发现一个真 bug："
     cells = [

railmux-0.4.1.dev5/src/railmux/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.4.1.dev5"