[cboulay]

Adds a live view of the data flowing through any publisher, alongside the
existing topology, settings and profiling views.

Click View Data on an expanded publisher row and a dock opens showing what
that publisher is sending.

How it works

The backend already holds a GraphContext, so it subscribes to the topic
directly — no unit injected, no shared-memory hop, no helper process. The tap
adds no edge to the topology and does not appear in profiling (both verified
against a live graph).

Two properties of ezmsg's Subscriber carry the design:

• leaky=True releases publisher backpressure for every notification it
  drops, so a wedged browser tab cannot stall the graph it is watching. This is
  the first thing to check in any "tap a live pipeline" scheme and ezmsg already
  provides it.
• recv_zero_copy() lends the message without pickling it. Everything
  downstream either copies into the ring or copies explicitly.

Leakiness costs contiguity, so each tap owns a ring written at message rate and
read at frame rate, and reports gaps instead of drawing across them.

Views

The view follows the data, and a stream supporting more than one offers a
dropdown — switching is a different reading of the same frames, so it needs no
re-subscription.

stream	opens as	also offers
(time, ch)	sweep	channel map, when the ch axis carries real x/y
(freq, ch)	spectrum	—
(ch) + positions	channel map	sweep
anything else	message inspector	—

The inspector reports type, dims, axes and attrs for any topic, including
ones no plot can draw.

Cost to the graph

Sample data is reduced before it is sent — to the plot's pixel width, over a
selectable time window. Bandwidth follows columns per second rather than the
publisher's sample rate:

stream	measured
8 ch @ 1 kHz	0.1 MB/s
256 ch @ 30 kHz	0.7 MB/s
2048 ch @ 1 kHz	5.8 MB/s

Optional dependency

Plotting needs the viz extra (pip install "ezmsg-dashboard[viz]"), which
adds ezmsg-tools for its AxisArray-to-plottable reduction — pure numpy, its Qt
and phosphor dependencies sit behind its own extras. Without it the message
inspector still works on every topic and only the plotting views are lost.

Two limits worth knowing

• The dashboard can only read topics whose message class it can import.
  ezmsg unpickles in the subscribing process, so a type defined in a script's
  __main__, or from a package the dashboard's environment lacks, never
  arrives. The panel detects this (an active publisher with no messages) and
  says so rather than looking idle. Fixing it properly needs something at the
  ezmsg layer.
• A stream wider than the browser's WebGL texture limit (8192 channels on
  current hardware, 2048 at the spec minimum) cannot be held in a plot buffer.
  The panel reports that and falls back to the inspector rather than drawing a
  subset under the whole stream's labels. Below that, wide streams are scrolled,
  512 lanes at a time.

Notes for review

Some non-obvious choices, each arrived at by fixing something that failed
silently — the code comments carry the detail:

• The renderer's ring is a texture, not a vertex buffer. The obvious
  strided-attribute layout works to 63 channels and then draws nothing:
  vertexAttribPointer rejects a stride above 252 bytes, while uploads and draw
  calls still succeed.
• The decimation ratio comes from a time window, not the frame rate.
  Without it a 30 kHz stream showed 33 ms and repainted entirely every frame.
• Autoscale measures only the visible lanes, over the whole window. Scanning
  every channel lets a loud feature flatten a quiet one against the rail;
  measuring one frame rather than the window clips the trace.
• bfloat16 is widened by reinterpreting its bits in numpy. Asking MLX to
  cast returns NaN and ~2.5e38 for an array that arrived over ezmsg's transport,
  because the cast runs on a device that cannot address the buffer — silently
  wrong rather than failing.

Testing

156 backend tests, 82 frontend unit tests, 32 Playwright e2e, ruff clean.

frontend/scripts/check-stream-panel.mjs additionally drives the dashboard in a
real browser against examples/stream_demo_graph.py and asserts each view
renders — shader compilation and "is anything drawn" cannot fail in jsdom. See
the Development Guide for how to run it.

Verified by hand against a live 256-channel 30 kHz pipeline, including
MLX-backed (float32, float16, bfloat16) payloads.

🤖 Generated with Claude Code