better-rtplot 0.4.9__tar.gz → 0.4.11__tar.gz

{better_rtplot-0.4.9 → better_rtplot-0.4.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: better-rtplot
-Version: 0.4.9
+Version: 0.4.11
 Summary: 
 License: GPL V3.0
 Author: jmontp

{better_rtplot-0.4.9 → better_rtplot-0.4.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "better-rtplot"
-version = "0.4.9"
+version = "0.4.11"
 description = ""
 authors = ["jmontp <jmontp@umich.edu>"]
 license = "GPL V3.0"

{better_rtplot-0.4.9 → better_rtplot-0.4.11}/rtplot/client.py

@@ -22,7 +22,7 @@ socket = context.socket(zmq.PUB)
 control_socket = context.socket(zmq.PULL)
 control_socket.setsockopt(zmq.RCVHWM, 1000)
 #Non-blocking local state for controls, drained on each poll_controls() call
-_control_slider_values = {}
+_control_values = {}
 _control_button_events = []
 
 # Cached payload of the most recent initialize_plots() call. The server
@@ -247,10 +247,27 @@ class Text:
         })
 
 
+@dataclass
+class TextInput:
+    id: str
+    label: str
+    value: str = ""
+    placeholder: Optional[str] = None
+    max_length: Optional[int] = None
+    height: Optional[float] = None
+
+    def to_dict(self):
+        return _drop_none({
+            "type": "text_input", "id": self.id, "label": self.label,
+            "value": self.value, "placeholder": self.placeholder,
+            "max_length": self.max_length, "height": self.height,
+        })
+
+
 @dataclass
 class ControlsRow:
     """A row of control widgets, rendered in place of a plot."""
-    controls: List[Union[Button, Slider, Dial, Display, Text, dict]] = field(default_factory=list)
+    controls: List[Union[Button, Slider, Dial, Display, Text, TextInput, dict]] = field(default_factory=list)
 
     def to_dict(self):
         return {"controls": [
@@ -536,7 +553,9 @@ def _send_initialize_with_handshake(cfg, timeout):
             elif evtype == "button":
                 _control_button_events.append(event.get("id"))
             elif evtype == "slider":
-                _control_slider_values[event.get("id")] = float(event.get("value", 0.0))
+                _control_values[event.get("id")] = float(event.get("value", 0.0))
+            elif evtype == "text":
+                _control_values[event.get("id")] = str(event.get("value", ""))
             # Unknown / resend_config: ignore during handshake.
         # Resend if the window elapsed without an ack; PUB/SUB will
         # drop the first send during slow-join but retries land.
@@ -575,8 +594,8 @@ def poll_controls():
     """Drain the return channel non-blocking and return current control state.
 
     Returns a ControlState(values, buttons) where:
-      - values: dict of {slider_id: float} with the latest value of every
-        slider the server has told us about since process start.
+      - values: dict of latest control values keyed by id. Sliders/dials
+        remain floats; text_input controls remain strings.
       - buttons: list of button ids that fired since the previous poll
         (cleared after this call).
 
@@ -587,7 +606,7 @@ def poll_controls():
     Reconnect button on a tab), it asks us to re-publish the cached
     initialize_plots() payload so the plot rewires without the user
     restarting their script. The request is consumed silently — the
-    returned ControlState only ever contains slider/button events.
+    returned ControlState only ever contains control/button events.
     """
     global _control_button_events
     while True:
@@ -601,7 +620,9 @@ def poll_controls():
         if evtype == "button":
             _control_button_events.append(event.get("id"))
         elif evtype == "slider":
-            _control_slider_values[event.get("id")] = float(event.get("value", 0.0))
+            _control_values[event.get("id")] = float(event.get("value", 0.0))
+        elif evtype == "text":
+            _control_values[event.get("id")] = str(event.get("value", ""))
         elif evtype == "resend_config":
             if plot_desc_dict is not None:
                 socket.send_string(SENDING_PLOT_UPDATE)
@@ -615,7 +636,7 @@ def poll_controls():
 
     buttons = _control_button_events
     _control_button_events = []
-    return ControlState(values=dict(_control_slider_values), buttons=buttons)
+    return ControlState(values=dict(_control_values), buttons=buttons)
 
 
 def save_snapshot(path, server_url=None, animate=False, timeout=5.0):
@@ -664,4 +685,4 @@ def save_snapshot(path, server_url=None, animate=False, timeout=5.0):
     abs_path = _os.path.abspath(path)
     with open(abs_path, "wb") as fh:
         fh.write(body)
-    return abs_path
+    return abs_path

{better_rtplot-0.4.9 → better_rtplot-0.4.11}/rtplot/server_browser.py

@@ -23,6 +23,8 @@ import asyncio
 import dataclasses
 import json
 import os
+import socket
+import subprocess
 import struct
 import sys
 import time
@@ -36,6 +38,7 @@ from typing import Optional
 import numpy as np
 import zmq
 import zmq.asyncio
+from zmq.utils.monitor import recv_monitor_message
 
 # pyzmq's asyncio integration needs event_loop.add_reader(), which the
 # Windows-default ProactorEventLoop (Python 3.8+) does not implement.
@@ -206,6 +209,7 @@ MSG_DELTA = 1
 
 ZMQ_DEFAULT_PORT = 5555
 ZMQ_CONTROL_PORT = ZMQ_DEFAULT_PORT + 1
+TCP_PROBE_TIMEOUT = 0.5
 
 RECEIVED_PLOT_UPDATE = 0
 RECEIVED_DATA = 1
@@ -262,6 +266,84 @@ def _control_target_from_data(ip):
     return f"{raw}:{ZMQ_CONTROL_PORT}"
 
 
+def _host_port_from_endpoint(endpoint, default_port=ZMQ_DEFAULT_PORT):
+    """Parse ``tcp://host:port`` or ``host[:port]`` into ``(host, port)``."""
+    raw = endpoint.strip()
+    if raw.startswith("tcp://"):
+        raw = raw[len("tcp://"):]
+    if raw.count(":") >= 1:
+        host, port_str = raw.rsplit(":", 1)
+    else:
+        host, port_str = raw, str(default_port)
+    try:
+        port = int(port_str)
+    except ValueError:
+        port = default_port
+    return host, port
+
+
+def _probe_tcp_endpoint(endpoint, timeout=TCP_PROBE_TIMEOUT):
+    """Return ``(open, reachable, error)`` for a TCP endpoint.
+
+    ``Connection refused`` still proves the host answered at the network
+    layer, so it is reachable even though that particular port is closed.
+    """
+    host, port = _host_port_from_endpoint(endpoint)
+    try:
+        with socket.create_connection((host, port), timeout=timeout):
+            return True, True, None
+    except ConnectionRefusedError as exc:
+        return False, True, str(exc)
+    except OSError as exc:
+        return False, False, str(exc)
+
+
+def _ping_host(host):
+    """Best-effort host reachability fallback for firewalled TCP ports."""
+    if not host or host == "*":
+        return False
+    if sys.platform == "win32":
+        cmd = ["ping", "-n", "1", "-w", "700", host]
+    else:
+        cmd = ["ping", "-c", "1", "-W", "1", host]
+    try:
+        return subprocess.run(
+            cmd,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=1.5,
+            check=False,
+        ).returncode == 0
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+
+
+def _probe_connect_target(endpoint):
+    """Classify a connect-mode target for the browser status dot.
+
+    Returns ``(host_reachable, rtplot_ports_open, error)``. A reachable host
+    with closed rtplot ports is still a usable tab: ZeroMQ can connect now and
+    auto-complete the connection later when the sender starts listening.
+    """
+    host, data_port = _host_port_from_endpoint(endpoint)
+    data_open, data_reachable, data_err = _probe_tcp_endpoint(endpoint)
+    ctrl_endpoint = _control_target_from_data(endpoint)
+    ctrl_open, ctrl_reachable, ctrl_err = _probe_tcp_endpoint(
+        ctrl_endpoint, timeout=TCP_PROBE_TIMEOUT
+    )
+    host_reachable = data_reachable or ctrl_reachable
+    if not host_reachable and _ping_host(host):
+        host_reachable = True
+    if not host_reachable:
+        return (
+            False,
+            False,
+            f"{host} unreachable (data {data_port}: {data_err}; "
+            f"control {data_port + 1}: {ctrl_err})",
+        )
+    return True, bool(data_open and ctrl_open), None
+
+
 ###############################
 # Tab model #
 ###############################
@@ -274,7 +356,7 @@ class Tab:
     name: str
     mode: str                 # "bind" or "connect"
     endpoint: str             # user-visible label, e.g. "*:5555" or "pi1:5555"
-    status: str = "idle"      # idle | streaming | error
+    status: str = "idle"      # idle | connecting | connected | streaming | error
     error: Optional[str] = None
 
     # Plot state
@@ -293,6 +375,7 @@ class Tab:
     layout: list = field(default_factory=list)
     control_rows: list = field(default_factory=list)
     slider_values: dict = field(default_factory=dict)
+    text_values: dict = field(default_factory=dict)
     display_values: dict = field(default_factory=dict)
     display_dirty: set = field(default_factory=set)
     fps: float = 0.0
@@ -302,6 +385,7 @@ class Tab:
     data_sock: Optional[zmq.Socket] = None
     ctrl_sock: Optional[zmq.Socket] = None
     receiver_task: Optional[asyncio.Task] = None
+    monitor_task: Optional[asyncio.Task] = None
 
     # Data buffer, lazy-allocated on first use (roughly 4 GB virtual,
     # but pages in only when written on Linux/Windows — a single tab
@@ -416,6 +500,7 @@ def parse_config(tab: Tab, json_config):
     trace_info = []
     control_rows = []
     slider_values = {}
+    text_values = {}
     layout = []
     num_datapoints_in_plot = DEFAULT_NUM_DATAPOINTS_IN_PLOT
 
@@ -431,6 +516,8 @@ def parse_config(tab: Tab, json_config):
             for element in row:
                 if element.get("type") in ("slider", "dial") and "value" in element:
                     slider_values[element["id"]] = float(element["value"])
+                elif element.get("type") == "text_input":
+                    text_values[element["id"]] = str(element.get("value", ""))
             layout.append({"kind": "controls", "index": len(control_rows)})
             control_rows.append(row)
             continue
@@ -463,6 +550,17 @@ def parse_config(tab: Tab, json_config):
     }
     tab.display_dirty = {d for d in tab.display_dirty if d in active_display_ids}
     tab.slider_values = slider_values
+    active_text_ids = {
+        el["id"]
+        for row in control_rows
+        for el in row
+        if el.get("type") == "text_input"
+    }
+    tab.text_values = {
+        text_id: tab.text_values.get(text_id, default_value)
+        for text_id, default_value in text_values.items()
+        if text_id in active_text_ids
+    }
     tab.layout = layout
 
     num_traces = sum(traces_per_plot)
@@ -502,11 +600,20 @@ def build_config_message(tab: Tab, config_dict) -> dict:
         "controls": tab.control_rows,
         "layout": tab.layout,
         "slider_values": dict(tab.slider_values),
+        "text_values": dict(tab.text_values),
         "display_values": dict(tab.display_values),
         "row_layout": bool(NEW_SUBPLOT_IN_ROW),
     }
 
 
+def refresh_config_message(tab: Tab):
+    """Rebuild the browser config payload using the tab's latest control state."""
+    if tab.config_dict is None:
+        tab.config_message = None
+    else:
+        tab.config_message = build_config_message(tab, tab.config_dict)
+
+
 ###############################
 # Binary payload construction #
 ###############################
@@ -618,9 +725,38 @@ def _open_tab_sockets(tab: Tab):
     # Close any prior sockets first (e.g. on retry).
     _close_tab_sockets(tab)
 
+    connect_label = tab.endpoint
+    connect_data_ep = None
+    if tab.mode == "connect":
+        try:
+            connect_data_ep, connect_label = _normalize_connect_target(tab.endpoint)
+        except Exception as exc:  # noqa: BLE001
+            tab.status = "error"
+            tab.error = f"invalid endpoint: {exc}"
+            print(f"[{tab.id}] ZMQ open failed: {tab.error}")
+            return
+
+        tab.endpoint = connect_label
+        tab.status = "connecting"
+        tab.error = None
+        host_reachable, rtplot_ports_open, peer_err = _probe_connect_target(connect_label)
+        if not host_reachable:
+            tab.status = "error"
+            tab.error = peer_err
+            print(f"[{tab.id}] peer probe failed: {peer_err}")
+            return
+        if not rtplot_ports_open:
+            tab.status = "idle"
+            tab.error = None
+            print(
+                f"[{tab.id}] host reachable, rtplot ports closed;"
+                f" waiting for ZMQ peer: {connect_label}"
+            )
+
     last_exc: Exception | None = None
     attempts = 4 if tab.mode == "bind" else 1
     for attempt in range(attempts):
+        monitor = None
         try:
             data = zmq_ctx.socket(zmq.SUB)
             data.setsockopt_string(zmq.SUBSCRIBE, "")
@@ -635,14 +771,20 @@ def _open_tab_sockets(tab: Tab):
                 tab.endpoint = f"*:{ZMQ_DEFAULT_PORT}"
                 print(f"[{tab.id}] ZMQ: bound on tcp://*:{ZMQ_DEFAULT_PORT}")
             else:
-                data_ep, label = _normalize_connect_target(tab.endpoint)
-                data.connect(data_ep)
+                monitor = data.get_monitor_socket(
+                    zmq.EVENT_CONNECTED
+                    | zmq.EVENT_DISCONNECTED
+                    | zmq.EVENT_CONNECT_DELAYED
+                    | zmq.EVENT_CONNECT_RETRIED
+                )
+                data.connect(connect_data_ep)
                 ctrl_ep, _ = _normalize_connect_target(
                     _control_target_from_data(tab.endpoint), port=ZMQ_CONTROL_PORT
                 )
                 ctrl.connect(ctrl_ep)
-                tab.endpoint = label
-                print(f"[{tab.id}] ZMQ: connected to {data_ep} (ctrl {ctrl_ep})")
+                tab.endpoint = connect_label
+                tab.monitor_task = asyncio.create_task(zmq_monitor(tab, monitor))
+                print(f"[{tab.id}] ZMQ: connecting to {connect_data_ep} (ctrl {ctrl_ep})")
 
             tab.data_sock = data
             tab.ctrl_sock = ctrl
@@ -657,6 +799,11 @@ def _open_tab_sockets(tab: Tab):
             except Exception: pass
             try: ctrl.close(0)
             except Exception: pass
+            try:
+                if monitor is not None:
+                    monitor.close(0)
+            except Exception:
+                pass
             if attempt < attempts - 1:
                 wait = 0.15 * (attempt + 1)
                 print(
@@ -692,6 +839,62 @@ async def _cancel_task(task):
         pass
 
 
+async def zmq_monitor(tab: Tab, monitor_sock):
+    """Track transport-level ZMQ state for connect-mode tabs."""
+    try:
+        while True:
+            evt = await recv_monitor_message(monitor_sock)
+            event = evt.get("event")
+            if event == zmq.EVENT_CONNECTED:
+                if tab.status in ("connecting", "idle") and not tab.initialized:
+                    tab.status = "connected"
+                    tab.error = None
+                    await broadcast_tab(tab.id)
+            elif event == zmq.EVENT_DISCONNECTED:
+                if tab.mode == "connect":
+                    host_reachable, rtplot_ports_open, peer_err = _probe_connect_target(tab.endpoint)
+                    if host_reachable and not rtplot_ports_open:
+                        tab.status = "idle"
+                        tab.error = None
+                    elif host_reachable:
+                        tab.status = "idle"
+                        tab.error = None
+                    else:
+                        tab.status = "error"
+                        tab.error = peer_err
+                    await broadcast_tab(tab.id)
+            elif event == zmq.EVENT_CONNECT_RETRIED:
+                if tab.mode == "connect" and tab.status == "error":
+                    host_reachable, _rtplot_ports_open, peer_err = _probe_connect_target(tab.endpoint)
+                    if host_reachable:
+                        tab.status = "idle"
+                        tab.error = None
+                    else:
+                        tab.error = peer_err
+                    await broadcast_tab(tab.id)
+            elif event == zmq.EVENT_CONNECT_DELAYED:
+                if tab.mode == "connect" and tab.status == "error":
+                    host_reachable, _rtplot_ports_open, peer_err = _probe_connect_target(tab.endpoint)
+                    if host_reachable:
+                        tab.status = "idle"
+                        tab.error = None
+                    else:
+                        tab.error = peer_err
+                    await broadcast_tab(tab.id)
+    except asyncio.CancelledError:
+        raise
+    except Exception as exc:  # noqa: BLE001
+        if tab.mode == "connect" and tab.status != "streaming":
+            tab.status = "error"
+            tab.error = f"ZMQ monitor error: {exc}"
+            await broadcast_tab(tab.id)
+    finally:
+        try:
+            monitor_sock.close(0)
+        except Exception:  # noqa: BLE001
+            pass
+
+
 async def send_control_event(tab: Tab, event):
     """Forward a control event to the user's Python process, best-effort."""
     if tab.ctrl_sock is None:
@@ -773,7 +976,7 @@ async def zmq_receiver(tab: Tab):
 
             tab.last_config_error = None  # clear: this one was good
             tab.config_dict = cfg
-            tab.config_message = build_config_message(tab, cfg)
+            refresh_config_message(tab)
             tab.initialized = True
             fps = None
             tab.fps = 0.0
@@ -797,6 +1000,10 @@ async def zmq_receiver(tab: Tab):
                 await send_control_event(
                     tab, {"type": "slider", "id": sid, "value": svalue}
                 )
+            for text_id, text_value in tab.text_values.items():
+                await send_control_event(
+                    tab, {"type": "text", "id": text_id, "value": text_value}
+                )
 
         elif category == RECEIVED_DATA:
             arr = await _recv_array_async(sock)
@@ -1003,6 +1210,7 @@ async def delete_tab(tab_id: str):
     if t is None:
         return
     await _cancel_task(t.receiver_task)
+    await _cancel_task(t.monitor_task)
     _close_tab_sockets(t)
     # Move any viewers off this tab back to bind_me on the browser side;
     # server tells them via tab_removed + they re-subscribe.
@@ -1091,6 +1299,8 @@ async def reconnect_tab(tab_id: str):
     if t is None:
         return
     await _cancel_task(t.receiver_task)
+    await _cancel_task(t.monitor_task)
+    t.monitor_task = None
     # _open_tab_sockets closes first, then reopens. Status gets set to
     # "idle" on success or "error" + a message on bind/connect failure.
     _open_tab_sockets(t)
@@ -1160,6 +1370,7 @@ async def handle_ws(request):
                         },
                     )
                     if t.config_message is not None:
+                        refresh_config_message(t)
                         await ws_send_text(ws, t.config_message)
                         if t.display_values:
                             await ws_send_text(
@@ -1220,9 +1431,21 @@ async def handle_ws(request):
                     t = tabs.get(tid)
                     if sid and t is not None:
                         t.slider_values[sid] = value
+                        refresh_config_message(t)
                         await send_control_event(
                             t, {"type": "slider", "id": sid, "value": value}
                         )
+                elif ptype == "control_text":
+                    text_id = payload.get("id")
+                    tid = ws_tab.get(ws, BIND_ME_ID)
+                    t = tabs.get(tid)
+                    if text_id and t is not None:
+                        value = str(payload.get("value", ""))
+                        t.text_values[text_id] = value
+                        refresh_config_message(t)
+                        await send_control_event(
+                            t, {"type": "text", "id": text_id, "value": value}
+                        )
             elif msg.type == WSMsgType.ERROR:
                 break
     finally:
@@ -1467,6 +1690,7 @@ async def on_cleanup(app):
         await _cancel_task(app.get(key))
     for t in list(tabs.values()):
         await _cancel_task(t.receiver_task)
+        await _cancel_task(t.monitor_task)
         _close_tab_sockets(t)
     for ws in list(ws_clients):
         try:

{better_rtplot-0.4.9 → better_rtplot-0.4.11}/rtplot/static/index.html

@@ -15,6 +15,7 @@
   .tab.active { background: #fff; color: #111; border-color: #bbb; font-weight: 600; }
   .tab .tab-dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: #bbb; flex: 0 0 auto; }
   .tab .tab-dot.idle { background: #bbb; }
+  .tab .tab-dot.connected { background: #e8b13a; box-shadow: 0 0 3px rgba(232,177,58,0.5); }
   .tab .tab-dot.streaming { background: #2ebf4e; box-shadow: 0 0 3px rgba(46,191,78,0.5); }
   .tab .tab-dot.error { background: #e05252; }
   .tab .tab-dot.connecting { background: #e8b13a; animation: pulse 1s ease-in-out infinite alternate; }
@@ -94,6 +95,8 @@
   .ctrl-numinput { width: 72px; font-family: monospace; font-size: calc(13px * var(--ui-scale)); padding: 4px 6px; border: 1px solid #b8b8b8; border-radius: 3px; background: #fff; color: #222; text-align: right; -moz-appearance: textfield; }
   .ctrl-numinput::-webkit-outer-spin-button,
   .ctrl-numinput::-webkit-inner-spin-button { -webkit-appearance: none; margin: 0; }
+  .ctrl-textinput { min-width: 200px; width: min(320px, 100%); font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; font-size: calc(13px * var(--ui-scale)); padding: 7px 10px; border: 1px solid #b8b8b8; border-radius: 3px; background: #fff; color: #222; text-align: left; }
+  .ctrl-textinput:focus { outline: none; border-color: #2a5db0; box-shadow: 0 0 0 2px rgba(42, 93, 176, 0.14); }
   .ctrl-nudgebtn { width: 26px; height: 26px; font-size: calc(15px * var(--ui-scale)); font-weight: 600; line-height: 1; padding: 0; border: 1px solid #b8b8b8; background: #f7f7f7; color: #333; cursor: pointer; border-radius: 3px; }
   .ctrl-nudgebtn:hover { background: #e9e9e9; }
   .ctrl-nudgebtn:active { background: #dcdcdc; }
@@ -414,7 +417,7 @@
       let socket = null;
       let pendingFrame = false;
       let lastStatus = { fps: 0, statusByte: 0, nonPlot: 0, peers: 0, dirty: true };
-      const controlElements = { displays: {}, displayFormats: {}, displayKinds: {}, sliders: {} };
+      const controlElements = { displays: {}, displayFormats: {}, displayKinds: {}, sliders: {}, textInputs: {} };
 
       function sendCtrl(msg) {
         if (socket && socket.readyState === WebSocket.OPEN) {
@@ -683,6 +686,34 @@
           item.appendChild(val);
           controlElements.displays[el.id] = val;
           controlElements.displayKinds[el.id] = 'text';
+        } else if (el.type === 'text_input') {
+          item.classList.add('ctrl-text-input', 'flex');
+          if (el.label) {
+            const lbl = document.createElement('label');
+            lbl.textContent = el.label;
+            item.appendChild(lbl);
+          }
+          const input = document.createElement('input');
+          input.type = 'text';
+          input.className = 'ctrl-textinput';
+          input.value = (el.value !== undefined && el.value !== null) ? String(el.value) : '';
+          if (el.placeholder !== undefined && el.placeholder !== null) {
+            input.placeholder = String(el.placeholder);
+          }
+          if (el.max_length !== undefined && Number.isFinite(Number(el.max_length))) {
+            input.maxLength = Number(el.max_length);
+          }
+          const commit = () => sendCtrl({ type: 'control_text', id: el.id, value: input.value });
+          input.addEventListener('change', commit);
+          input.addEventListener('blur', commit);
+          input.addEventListener('keydown', (e) => {
+            if (e.key === 'Enter') {
+              e.preventDefault();
+              commit();
+            }
+          });
+          item.appendChild(input);
+          controlElements.textInputs[el.id] = input;
         }
         return item;
       }
@@ -721,6 +752,14 @@
         }
       }
 
+      function applyTextValues(values) {
+        if (!values) return;
+        for (const [id, val] of Object.entries(values)) {
+          const input = controlElements.textInputs[id];
+          if (input) input.value = (val !== undefined && val !== null) ? String(val) : '';
+        }
+      }
+
       function applyDisplayValues(values) {
         if (!values) return;
         for (const [id, val] of Object.entries(values)) {
@@ -751,6 +790,7 @@
         controlElements.displayFormats = {};
         controlElements.displayKinds = {};
         controlElements.sliders = {};
+        controlElements.textInputs = {};
       }
 
       function showEmptyState(text) {
@@ -858,6 +898,7 @@
         });
         totalTraces = traceOffset;
         applySliderValues(cfg.slider_values);
+        applyTextValues(cfg.text_values);
         applyDisplayValues(cfg.display_values);
         // Render LaTeX in everything we just built: uPlot's title,
         // x/y axis labels, and legend (all rendered as HTML), plus the
@@ -987,6 +1028,19 @@
       }
 
       // ---- Tab bar rendering ----
+      function tabStatusTitle(t) {
+        if (t.error) return t.error;
+        if (t.status === 'streaming') return 'Receiving rtplot data';
+        if (t.status === 'connected') return 'ZMQ connected; waiting for plot config/data';
+        if (t.status === 'connecting') return 'Checking device connection';
+        if (t.status === 'idle') {
+          return t.mode === 'bind'
+            ? 'Listening for a sender'
+            : 'Host reachable; rtplot ports are not connected';
+        }
+        return 'Status unknown';
+      }
+
       function renderTabs() {
         tabbar.innerHTML = '';
         // Stable order: bind_me first, then others in insertion order.
@@ -1002,7 +1056,7 @@
 
           const dot = document.createElement('span');
           dot.className = 'tab-dot ' + (t.status || 'idle');
-          if (t.error) dot.title = t.error;
+          dot.title = tabStatusTitle(t);
           el.appendChild(dot);
 
           // Stacked labels: name on top, endpoint on a muted subline so