Render an existing .vl.json to svg, png, or SELF-CONTAINED interactive html (vega js inlined — opens in the browser, works offline). Refuses an out_path that collides with the spec (charter).

Write a Vega-Lite chart as a SOURCE DOCUMENT: .vl.json + a rendered .png land in out_dir (use the artifact scratch when the user asked to SEE it — the workspace opens it beside the conversation, live and editable). Pass data= to inline a frame (capped at max_rows — aggregate big data in the kernel first); a handle reads from the store, so it charts even after the kernel that made it died. THE RENDER COMES BACK ATTACHED TO THIS RESULT — look at it directly, no second read — alongside diagnostics, deterministic layout checks (label collisions, a zero baseline flattening the data, too many series) that name defects the image alone makes you squint for. Rendering is local (vl-convert, Vega-Lite v6).

Load a data file into the session kernel as DATA[name] — loaded once, use it many times: transform with py_run, chart with chart_spec(data=name). Starts the kernel on first use.

RETURNS A frame_handle as well as the profile. The handle is the durable name for this frame: it is written to a store that outlives the kernel, so if a wall-timeout kills the interpreter you can pass the handle back to py_run's frame_handles and carry on instead of reloading. Treat it as opaque; it is valid for ttl_ms.

Describe a data file (csv/tsv/parquet/xlsx/json) BEFORE plotting it: row count (sampled at 100k for huge csv), column dtypes, head, and numeric summary. Profile → design the chart → load. Reads the file on this machine; nothing leaves it.

EXECUTES Python in the session kernel — pandas, numpy, scipy, matplotlib (Agg), plotly, altair are importable; DATA holds loaded frames; variables and imports survive to your next call. Use it to transform/aggregate before charting, or run a python recipe (matplotlib figures: savefig to an absolute path in the artifact scratch). Resource-capped (memory rlimit + your wall_s, max 570s).

Pass frame_handles as {name: handle} to put stored frames back in DATA before the code runs — this is how you RECOVER after a timeout killed the kernel, and how any call gets a frame it did not load itself. Returns frame_handles for every frame in DATA afterwards, re-addressed if your code changed them, so the next call always has a durable name for the work this one did. You get them back even when the code raises. stdout/stderr come back bounded.

Empty the session kernel deliberately — loaded frames and variables are gone; the next data_load starts fresh.

What the kernel holds right now — loaded frames (rows × columns, each with its frame_handle) and user variables — plus stored_handles, the frames that survive the kernel. A wall-timeout or session_reset empties the first list and leaves the second.

Engineering chart recipes — call with no topic for the index, with a topic for a worked template: line, scatter, bar, histogram, cdf, log_axes, error_bars, tolerance_band, control_chart, heatmap (Vega-Lite, chart_spec-ready) and bode, fft, contour (python, via py_run). Templates teach the shape; adapt fields to your data.