@rho-workspace/rho 0.5.5 → 0.5.7

package/node_modules/@rho-workspace/plugin-kernel/dist/ui-notebook.js

@@ -1,11 +1,12 @@
-import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from 'react';
 import { statements, unfinished } from './statements.js';
 import { cellRelations } from './lineage.js';
 import { CellScriptFlow } from './ui-flow.js';
 import { Icon } from './ui-icons.js';
 import { PlaceChip, usePlaces, whereOf } from './ui-servers.js';
 import { takeCell } from './ui-notebook-target.js';
+import { scopedCells } from './session-scope.js';
 import { call, refused, agentName, clock, durationText, useShell, withShell, versionOf } from './ui-base.js';
 export { versionOf };
 export const languages = ['r', 'python'];
@@ -69,13 +70,30 @@ export function usePlot(client, projectId, cellId, plot) {
     }, [client, projectId, cellId, plot]);
     return { src, problem };
 }
+// What a figure on this page needs from it: who ran what, and the page's event cursor.
+const FigureFacts = createContext({});
+function WithFacts({ snapshot, children }) {
+    const who = useAuthors(snapshot), cursor = snapshot.cursor;
+    return _jsx(FigureFacts.Provider, { value: useMemo(() => ({ who, cursor }), [who, cursor]), children: children });
+}
+// A plot an extension described is drawn by the page's figure, with the picture standing in until
+// then; one it could not describe says why under its picture.
+function useFigure(client, projectId, cell, output, label, picture, fit = false) {
+    const { figure } = useShell(), facts = useContext(FigureFacts);
+    if (!output.figure || !figure)
+        return null;
+    return figure({ client, projectId, cellId: cell.cellId, plot: output.plot, width: output.width || 1008, height: output.height || 720, label, name: `${languageName[cell.language]} cell ${cell.number}, plot ${output.plot}`, fit, cursor: facts.cursor, fallback: picture,
+        author: facts.who && (by => ({ name: facts.who(by).name, mine: by === me })) });
+}
 function Plot({ client, projectId, cell, output, label }) {
     const { src, problem } = usePlot(client, projectId, cell.cellId, output.plot);
     // Plots are drawn at twice the size they are shown at, for sharp lines on dense screens.
     const width = Math.round((output.width || 1008) / 2), height = Math.round((output.height || 720) / 2);
+    const picture = _jsx("figure", { className: "nb-plot", style: { maxWidth: width }, children: src ? _jsx("img", { src: src, width: width, height: height, alt: label }) : _jsx("div", { className: "nb-plot-wait", style: { aspectRatio: `${width} / ${height}` }, "aria-label": "Reading the plot" }) });
+    const described = useFigure(client, projectId, cell, output, label, picture);
     if (problem)
         return _jsxs("p", { className: "nb-note", children: ["This plot could not be read. ", problem] });
-    return _jsx("figure", { className: "nb-plot", style: { maxWidth: width }, children: src ? _jsx("img", { src: src, width: width, height: height, alt: label }) : _jsx("div", { className: "nb-plot-wait", style: { aspectRatio: `${width} / ${height}` }, "aria-label": "Reading the plot" }) });
+    return _jsxs(_Fragment, { children: [described ?? picture, output.figureProblem && _jsxs("p", { className: "nb-note", children: ["Its marks are not selectable: ", output.figureProblem] })] });
 }
 export function Code({ code, language }) {
     const lines = code.replace(/\n+$/, '').split('\n');
@@ -100,12 +118,23 @@ function Printed({ output }) {
     const long = output.kind !== 'error' && lines.length > notebookViewLimits.outputLines + 4;
     return _jsxs(_Fragment, { children: [_jsx("pre", { className: 'nb-out ' + output.kind, children: long && !whole ? lines.slice(0, notebookViewLimits.outputLines).join('\n') : lines.join('\n') }), long && _jsx("button", { className: "text-button nb-more nb-out-more", onClick: () => setWhole(!whole), children: whole ? 'Show less' : `Show all ${lines.length} lines` })] });
 }
+function Saved({ client, projectId, cell, saved }) {
+    const { figure, openPath } = useShell(), facts = useContext(FigureFacts);
+    const name = saved.path.split('/').at(-1);
+    const head = _jsxs("p", { className: "nb-saved", children: [_jsx("span", { children: "Saved" }), openPath ? _jsx("button", { className: "text-button", title: 'Show ' + saved.path, onClick: () => openPath(saved.path), children: saved.path }) : _jsx("code", { children: saved.path }), saved.figure ? _jsxs("span", { className: "nb-saved-what", children: [saved.figure.bound.toLocaleString(), " ", saved.figure.bound === 1 ? 'mark' : 'marks', " bound to their rows"] })
+                : saved.figureProblem ? _jsxs("span", { className: "nb-saved-what", children: ["kept as a picture: ", saved.figureProblem] }) : null] });
+    if (!saved.figure || !figure)
+        return head;
+    return _jsxs(_Fragment, { children: [head, figure({ client, projectId, file: { path: saved.path, sha256: saved.sha256 }, width: 1008, label: `${name}, saved by ${cell.purpose ?? 'this cell'}`, name: `${name} (${languageName[cell.language]} cell ${cell.number})`,
+                cursor: facts.cursor, fallback: _jsx("div", { className: "nb-plot-wait", style: { maxWidth: 504, aspectRatio: '7 / 5' }, "aria-label": "Reading the figure" }),
+                author: facts.who && (by => ({ name: facts.who(by).name, mine: by === me })) })] });
+}
 function Outputs({ cell, client, projectId }) {
     let plots = 0;
     const purpose = cell.purpose ?? 'this cell';
     return _jsxs(_Fragment, { children: [cell.outputs.map((output, i) => output.kind === 'plot'
                 ? _jsx(Plot, { client: client, projectId: projectId, cell: cell, output: output, label: `Plot ${++plots} drawn by ${purpose}` }, i)
-                : _jsx(Printed, { output: output }, i)), cell.cut && _jsxs("p", { className: "nb-note", children: ["Only the first ", sizeText(cell.kept), " of the ", sizeText(cell.bytes), " it printed were kept."] })] });
+                : _jsx(Printed, { output: output }, i)), (cell.saved ?? []).map(saved => _jsx(Saved, { client: client, projectId: projectId, cell: cell, saved: saved }, saved.number)), cell.cut && _jsxs("p", { className: "nb-note", children: ["Only the first ", sizeText(cell.kept), " of the ", sizeText(cell.bytes), " it printed were kept."] })] });
 }
 const sizeText = (bytes) => bytes < 1024 ? bytes + ' bytes' : bytes < 1024 * 1024 ? Math.round(bytes / 1024) + ' KB' : (bytes / 1024 / 1024).toFixed(1) + ' MB';
 function Ending({ cell, now }) {
@@ -286,7 +315,7 @@ function ConsoleCell({ cell, author, who, client, projectId, now, plotsBeside, p
     const interrupted = cell.interrupt ? `Interrupted by ${who(cell.interrupt.by).name === 'You' ? 'you' : who(cell.interrupt.by).name}` : null;
     return _jsxs("div", { className: 'nbc-cell ' + cell.state + ' ' + cell.language, id: 'cell-' + cell.cellId, children: [author.name !== 'You' && _jsxs("p", { className: "nbc-who", children: ["# ", author.conversationId ? _jsx("button", { className: "text-button", title: author.title ? 'Open ' + author.title : undefined, onClick: () => onConversation(author.conversationId), children: author.name }) : author.name, cell.purpose ? ' · ' + cell.purpose : ''] }), _jsx(PromptCode, { code: cell.code, language: cell.language }), cell.outputs.map((output, i) => output.kind === 'plot'
                 ? _jsx(ConsolePlot, { client: client, projectId: projectId, cell: cell, output: output, number: plotNumber(cell.cellId, output.plot), beside: plotsBeside }, i)
-                : _jsx("pre", { className: 'nbc-out ' + output.kind, children: (output.text ?? '').replace(/\n$/, '') }, i)), cell.cut && _jsxs("p", { className: "nbc-quiet", children: ["Only the first ", sizeText(cell.kept), " of the ", sizeText(cell.bytes), " it printed were kept."] }), cell.state === 'running' && _jsxs("p", { className: "nbc-state running", children: [_jsx("span", { className: "pulse-dot", "aria-hidden": "true" }), "Running ", durationText(now - Date.parse(cell.startedAt ?? cell.queuedAt))] }), cell.state === 'queued' && _jsx("p", { className: "nbc-state", children: "Waiting for the cell before it" }), (interrupted || cell.state === 'not-run' || cell.state === 'unknown' || (cell.problem && cell.state !== 'error' && cell.state !== 'interrupted')) &&
+                : _jsx("pre", { className: 'nbc-out ' + output.kind, children: (output.text ?? '').replace(/\n$/, '') }, i)), (cell.saved ?? []).map(saved => _jsxs("p", { className: "nbc-quiet", children: ["# Saved ", saved.path, saved.figure ? ` · ${saved.figure.bound.toLocaleString()} marks bound` : saved.figureProblem ? ` · kept as a picture: ${saved.figureProblem}` : ''] }, saved.number)), cell.cut && _jsxs("p", { className: "nbc-quiet", children: ["Only the first ", sizeText(cell.kept), " of the ", sizeText(cell.bytes), " it printed were kept."] }), cell.state === 'running' && _jsxs("p", { className: "nbc-state running", children: [_jsx("span", { className: "pulse-dot", "aria-hidden": "true" }), "Running ", durationText(now - Date.parse(cell.startedAt ?? cell.queuedAt))] }), cell.state === 'queued' && _jsx("p", { className: "nbc-state", children: "Waiting for the cell before it" }), (interrupted || cell.state === 'not-run' || cell.state === 'unknown' || (cell.problem && cell.state !== 'error' && cell.state !== 'interrupted')) &&
                 _jsx("p", { className: "nbc-state", children: interrupted ?? (cell.state === 'not-run' ? 'Not run' : cell.state === 'unknown' ? 'Outcome unknown' : cell.problem) })] });
 }
 function ConsoleMark({ session, edge, who }) {
@@ -422,26 +451,19 @@ export function SessionPane({ client, snapshot, prepared, onTaken, onConversatio
         observer.observe(element);
         return () => observer.disconnect();
     }, []);
-    return withShell(shell, _jsx("div", { className: "nb-view", ref: box, children: _jsx(NotebookBody, { client: client, snapshot: snapshot, onConversation: onConversation ?? (() => { }), compact: !wide, inView: true, shown: shown, prepared: prepared, onTaken: onTaken, onObject: onObject, beside: beside, form: form, scope: scope }) }));
+    return withShell(shell, _jsx(WithFacts, { snapshot: snapshot, children: _jsx("div", { className: "nb-view", ref: box, children: _jsx(NotebookBody, { client: client, snapshot: snapshot, onConversation: onConversation ?? (() => { }), compact: !wide, inView: true, shown: shown, prepared: prepared, onTaken: onTaken, onObject: onObject, beside: beside, form: form, scope: scope }) }) }));
 }
 // The Notebook as a page of its own, or inside a view. The page that shows it may give it the
 // application's code highlighting.
 export function NotebookPage({ shell, ...props }) {
-    return withShell(shell, _jsx(NotebookBody, { ...props }));
+    return withShell(shell, _jsx(WithFacts, { snapshot: props.snapshot, children: _jsx(NotebookBody, { ...props }) }));
 }
 function NotebookBody({ client, snapshot, onConversation, onObject, scope, compact = false, inView = false, shown = 0, prepared, onTaken, beside = {}, form = 'notebook' }) {
     const projectId = snapshot.project.id;
     const { read, off, problem, again } = useKernel(client, projectId, snapshot.cursor);
     const { places, setPlaces } = usePlaces(client, projectId, snapshot.cursor);
     const who = useAuthors(snapshot);
-    const cells = useMemo(() => {
-        const all = read?.cells ?? [];
-        if (!scope)
-            return all;
-        const theirs = new Set(all.filter(c => c.by === scope.principal).map(c => c.sessionId));
-        return all.filter(c => (theirs.has(c.sessionId) || (c.by === me && scope.since !== null && Date.parse(c.queuedAt) >= scope.since))
-            && (scope.at === null || Date.parse(c.queuedAt) <= scope.at));
-    }, [read, scope?.principal, scope?.since, scope?.at]);
+    const cells = useMemo(() => scopedCells(read?.cells ?? [], scope), [read, scope?.principal, scope?.since, scope?.at, scope?.cellIds]);
     const latest = useMemo(() => {
         const out = {};
         for (const s of read?.sessions ?? [])
@@ -679,7 +701,10 @@ export function VariablesPane({ client, snapshot, onObject }) {
 // the ones before it to step back through. A new plot comes forward as it is drawn. Plots of an
 // ended session stay with their cells in the Notebook.
 export const plotsPaneLimits = { plots: 24 };
-export function PlotsPane({ client, snapshot }) {
+export function PlotsPane({ client, snapshot, shell }) {
+    return withShell(shell, _jsx(WithFacts, { snapshot: snapshot, children: _jsx(Plots, { client: client, snapshot: snapshot }) }));
+}
+function Plots({ client, snapshot }) {
     const projectId = snapshot.project.id;
     const { read, off, problem } = useKernel(client, projectId, snapshot.cursor);
     const who = useAuthors(snapshot);
@@ -711,9 +736,11 @@ export function PlotsPane({ client, snapshot }) {
 }
 function PlotFit({ client, projectId, cell, output, label }) {
     const { src, problem } = usePlot(client, projectId, cell.cellId, output.plot);
+    const picture = _jsx("figure", { className: "nb-plots-fit", children: src ? _jsx("img", { src: src, alt: label }) : _jsx("span", { className: "nb-plot-wait", "aria-label": "Reading the plot" }) });
+    const described = useFigure(client, projectId, cell, output, label, picture, true);
     if (problem)
         return _jsxs("p", { className: "nb-note", children: ["This plot could not be read. ", problem] });
-    return _jsx("figure", { className: "nb-plots-fit", children: src ? _jsx("img", { src: src, alt: label }) : _jsx("span", { className: "nb-plot-wait", "aria-label": "Reading the plot" }) });
+    return described ? _jsx("div", { className: "nb-plots-figure", children: described }) : picture;
 }
 function PlotThumb({ client, projectId, cell, output, current, label, onShow }) {
     const { src } = usePlot(client, projectId, cell.cellId, output.plot);

package/node_modules/@rho-workspace/plugin-kernel/dist/ui-styles.js

@@ -40,6 +40,10 @@ const styles = `/* The Notebook: cells in the order they ran beside the live ses
 .nb-plot img { display: block; width: 100%; height: auto; border: 1px solid var(--color-hairline); border-radius: 6px; background: #fff; }
 .nb-plot-wait { display: block; width: 100%; border-radius: 6px; background: var(--color-well); }
 .nb-note { color: var(--color-meta); font-size: 12px; }
+.nb-saved { display: flex; flex-wrap: wrap; align-items: baseline; gap: 4px 8px; margin: 6px 0; font-size: 12px; color: var(--color-meta); }
+.nb-saved > span:first-child { font-weight: 600; color: var(--color-ink); }
+.nb-saved .text-button { font-family: var(--font-mono, ui-monospace, monospace); font-size: 12px; overflow-wrap: anywhere; }
+.nb-saved-what { overflow-wrap: anywhere; }
 .nb-body > .nb-note { padding-left: 12px; }
 .nb-problem { padding-left: 12px; color: var(--color-amber-text); font-size: 12.5px; }
 .nb-actions { display: flex; gap: 16px; padding-left: 12px; }
@@ -188,6 +192,8 @@ button.nb-cell-link:hover { background: var(--color-hover); text-decoration: und
 .nb-plots-fit { flex: 1; display: flex; align-items: center; justify-content: center; min-height: 0; margin: 0; }
 .nb-plots-fit img { max-width: 100%; max-height: 100%; object-fit: contain; border: 1px solid var(--color-hairline); border-radius: 6px; background: #fff; }
 .nb-plots-fit .nb-plot-wait { width: min(100%, 504px); aspect-ratio: 7 / 5; }
+.nb-plots-figure { flex: 1; min-height: 0; display: flex; flex-direction: column; }
+.nb-plots-figure > .fig { flex: 1; min-height: 0; }
 .nb-plots-strip { display: flex; flex: none; gap: 6px; overflow-x: auto; padding: 2px; }
 .nb-plots-thumb { flex: none; width: 72px; min-height: 0; padding: 2px; border: 1px solid var(--color-hairline); border-radius: 6px; background: var(--color-surface); }
 .nb-plots-thumb[aria-current="true"] { border-color: var(--color-accent); box-shadow: 0 0 0 1px var(--color-accent); }

package/node_modules/@rho-workspace/plugin-kernel/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rho-workspace/plugin-kernel",
-  "version": "0.5.5",
+  "version": "0.5.13",
   "type": "module",
   "description": "Rho live session plugin: an R and a Python session the Agent and the person run code in, kept with each cell's output, plots and the session's variables",
   "license": "AGPL-3.0-only",

package/node_modules/@rho-workspace/plugin-kernel/runners/runner.R

@@ -161,7 +161,98 @@ call_text <- function(condition) {
 # that draws several keeps each; a cell reports the pages it drew or changed, drawn to files at
 # its end. A device the code opens itself is its own.
 device <- NULL; seen <- NULL; plots <- list()
+# Plugins can describe what a page draws (RHO_KERNEL_EXTENSIONS names their R files). Each file is
+# sourced into an environment of its own; page_object() names the object a page starts drawing,
+# and describe_page() writes a record beside the page's picture. One that fails is left out, and a
+# page whose object no extension describes stays a picture.
+extensions <- list()
+for (file in strsplit(Sys.getenv("RHO_KERNEL_EXTENSIONS"), .Platform$path.sep, fixed = TRUE)[[1]]) {
+  if (!nzchar(file)) next
+  env <- new.env(parent = baseenv())
+  if (!inherits(tryCatch(sys.source(file, envir = env), error = function(e) e), "error")) extensions[[length(extensions) + 1]] <- env
+}
+page_object <- NULL
+# Pages the code saved to files of its own (ggsave): an extension names the plot, the file and the
+# size, and the page is described when the cell ends, once the file is written. A file saved twice
+# keeps its last page.
+saving <- list()
+absolute <- function(file) if (grepl("^(/|~|[A-Za-z]:[/\\\\])", file)) path.expand(file) else file.path(getwd(), file)
+# A device the code opens on a file (png(), pdf(), svg() and the others grDevices names) is noted
+# with its file. Each page drawn there is recorded as it is drawn: before the next page starts,
+# after each top-level expression and before dev.off() closes it. When it closes, its last page (or
+# each page, for a file name numbered with %d) is described as a figure of its file, as a page
+# ggsave() saved is. The runner's own devices are not noted. A device opened through a function a
+# package imported before the session started is not seen; its file stays a picture.
+drawing <- list(); closed <- list(); own_devices <- FALSE
+numbered <- function(file) grepl("%[#0 +-]*[0-9]*d", file)
+file_snapshot <- function(d) {
+  key <- as.character(d); f <- drawing[[key]]
+  if (is.null(f) || !length(f$pages) || !(d %in% grDevices::dev.list())) return()
+  current <- grDevices::dev.cur(); if (current != d) grDevices::dev.set(d)
+  p <- tryCatch(grDevices::recordPlot(), error = function(e) NULL); size <- grDevices::dev.size("in")
+  if (current != d) grDevices::dev.set(current)
+  if (!is.null(p) && length(drawn(p[[1]]))) drawing[[key]]$pages[[length(f$pages)]] <<- c(f$pages[[length(f$pages)]][c("object")], list(recorded = p, width = size[1], height = size[2]))
+}
+file_page <- function(d, grid) {
+  key <- as.character(d)
+  if (is.null(drawing[[key]])) return()
+  file_snapshot(d)
+  grDevices::dev.control("enable")
+  # A file that is not numbered keeps only its last page: earlier ones are counted, not kept.
+  n <- length(drawing[[key]]$pages)
+  if (n && !numbered(drawing[[key]]$file)) drawing[[key]]$pages[[n]] <<- list(object = NULL)
+  object <- NULL
+  if (grid) for (env in extensions) if (is.function(env$page_object)) {
+    found <- tryCatch(env$page_object(), error = function(e) NULL)
+    if (!is.null(found)) { object <- list(env = env, object = found); break }
+  }
+  drawing[[key]]$pages[[n + 1L]] <<- list(object = object)
+}
+device_opening <- function(env) assign(".rho_devices", grDevices::dev.list(), envir = env)
+device_opened <- function(env) tryCatch({
+  d <- grDevices::dev.cur(); before <- get0(".rho_devices", envir = env, inherits = FALSE)
+  if (d == 1L || d %in% before) return(invisible())
+  # A device number is used again once its device is closed; the runner's own device is never noted.
+  drawing[[as.character(d)]] <<- NULL
+  file <- get0("filename", envir = env, inherits = FALSE) %||% get0("file", envir = env, inherits = FALSE)
+  if (own_devices || identical(d, device) || !is.character(file) || length(file) != 1L || !nzchar(file)) return(invisible())
+  drawing[[as.character(d)]] <<- list(file = absolute(file), pages = list())
+  invisible()
+}, error = function(e) invisible())
+device_closing <- function(which) tryCatch({
+  d <- as.integer(which); key <- as.character(d)
+  if (length(d) != 1L || is.na(d) || is.null(drawing[[key]])) return(invisible())
+  file_snapshot(d)
+  closed[[length(closed) + 1L]] <<- drawing[[key]]; drawing[[key]] <<- NULL
+  invisible()
+}, error = function(e) invisible())
+invisible(utils::capture.output(suppressMessages(tryCatch(
+  for (where in list(asNamespace("grDevices"), as.environment("package:grDevices"))) {
+    for (f in intersect(c("png", "jpeg", "tiff", "bmp", "svg", "pdf", "cairo_pdf"), ls(where)))
+      trace(f, tracer = substitute(F(environment()), list(F = device_opening)), exit = substitute(F(environment()), list(F = device_opened)), where = where, print = FALSE)
+    trace("dev.off", tracer = substitute(F(which), list(F = device_closing)), where = where, print = FALSE)
+  }, error = function(e) NULL))))
+started_page <- function(grid) {
+  current <- grDevices::dev.cur()
+  if (!is.null(device) && current != device) {
+    if (grid) for (env in extensions) if (is.function(env$saved_page)) {
+      found <- tryCatch(env$saved_page(), error = function(e) NULL)
+      if (!is.null(found)) { found$env <- env; saving[[absolute(found$file)]] <<- found; drawing[[as.character(current)]] <<- NULL; return() }
+    }
+    file_page(current, grid)
+    return()
+  }
+  if (is.null(device) || grDevices::dev.cur() != device) return()
+  page_object <<- NULL
+  if (!grid) return()
+  for (env in extensions) if (is.function(env$page_object)) {
+    found <- tryCatch(env$page_object(), error = function(e) NULL)
+    if (!is.null(found)) { page_object <<- list(env = env, object = found); return() }
+  }
+}
 recording <- function() {
+  # A file the code opened and has not closed stays where it draws, as in the R console.
+  if (!is.null(drawing[[as.character(grDevices::dev.cur())]])) return()
   if (!is.null(device) && device %in% grDevices::dev.list()) { grDevices::dev.set(device); return() }
   grDevices::pdf(NULL, width = 7, height = 5); grDevices::dev.control("enable")
   device <<- grDevices::dev.cur(); seen <<- NULL
@@ -171,13 +262,17 @@ snapshot <- function() {
   current <- grDevices::dev.cur(); if (current != device) grDevices::dev.set(device)
   p <- grDevices::recordPlot()
   if (current != device) grDevices::dev.set(current)
-  if (length(drawn(p[[1]])) && !(length(seen) && same(drawn(p[[1]]), drawn(seen)))) { plots[[length(plots) + 1]] <<- p; seen <<- p[[1]] }
+  if (length(drawn(p[[1]])) && !(length(seen) && same(drawn(p[[1]]), drawn(seen)))) { attr(p, "rho_page") <- page_object; plots[[length(plots) + 1]] <<- p; seen <<- p[[1]] }
 }
-setHook("before.plot.new", function() snapshot())
-setHook("before.grid.newpage", function() snapshot())
+setHook("before.plot.new", function() { snapshot(); started_page(FALSE) })
+setHook("before.grid.newpage", function() { snapshot(); started_page(TRUE) })
 
+# A page drawn on a file, ready to be described as that file: the object an extension named when
+# the page started, else the page as it was recorded.
+drawn_page <- function(p) list(env = p$object$env %||% Find(function(env) is.function(env$describe_page), extensions),
+  object = p$object$object %||% p$recorded, width = p$width, height = p$height, recorded = p$recorded, quiet = TRUE)
 run <- function(msg) {
-  id <- msg$id; plots <<- list(); ok <- TRUE; interrupted <- FALSE
+  id <- msg$id; plots <<- list(); saving <<- list(); closed <<- list(); own_devices <<- FALSE; ok <- TRUE; interrupted <- FALSE
   known <- ls(globalenv()); seen <- lineage_of(msg$code); files <- project_paths(seen$strings)
   recording()
   tryCatch({
@@ -193,10 +288,13 @@ run <- function(msg) {
         warning = function(w) { say(list(id = id, kind = "warning", text = paste0("Warning", call_text(w), ": ", conditionMessage(w), "\n"))); invokeRestart("muffleWarning") },
         message = function(m) { say(list(id = id, kind = "stderr", text = conditionMessage(m))); invokeRestart("muffleMessage") })
       snapshot()
+      for (key in names(drawing)) file_snapshot(as.integer(key))
       if (!went) break
     }
   }, interrupt = function(e) { interrupted <<- TRUE; ok <<- FALSE; cat("\n") })
   # A session on a server draws in its own temporary folder and sends each plot with its answer.
+  # The devices drawn on from here are the runner's own.
+  own_devices <<- TRUE
   shown <- final_plots(plots); plots <<- list()
   for (i in seq_along(shown)) {
     if (i > msg$maxPlots) break
@@ -205,9 +303,51 @@ run <- function(msg) {
     tryCatch(grDevices::replayPlot(shown[[i]]), error = function(e) NULL)
     grDevices::dev.off()
     plot <- list(id = id, kind = "plot", file = file, width = 1008, height = 720)
+    # A page no extension named an object for (base graphics) is offered to them as it was recorded.
+    page <- attr(shown[[i]], "rho_page")
+    if (is.null(page)) for (env in extensions) if (is.function(env$describe_page)) { page <- list(env = env, object = shown[[i]]); break }
+    if (!is.null(page) && !isTRUE(msg$inline) && is.function(page$env$describe_page)) {
+      described <- tryCatch(page$env$describe_page(page$object, file, 7, 5, recorded = shown[[i]]), error = function(e) list(problem = conditionMessage(e)))
+      if (!is.null(described$problem)) plot$figureProblem <- as.character(described$problem)[1] else if (!is.null(described)) plot$figure <- described
+    }
     if (isTRUE(msg$inline)) { plot$data <- jsonlite::base64_enc(readBin(file, "raw", file.info(file)$size)); unlink(file) }
     say(plot)
   }
+  # A page saved to a file in the project is described at the size it was saved at; its record is
+  # kept with the cell's plots. A session on a server keeps none: its files are not here.
+  # Files the code drew to and closed, or whose device is gone, join them: a file numbered with %d
+  # holds each page, a PDF of several pages is not described, any other file holds its last page.
+  for (key in names(drawing)) if (!(as.integer(key) %in% grDevices::dev.list())) { closed[[length(closed) + 1L]] <<- drawing[[key]]; drawing[[key]] <<- NULL }
+  for (f in closed) {
+    n <- length(f$pages)
+    if (!n) next
+    if (numbered(f$file)) { for (j in seq_len(n)) if (!is.null(f$pages[[j]]$recorded)) saving[[sprintf(f$file, j)]] <<- drawn_page(f$pages[[j]]) }
+    else if (n > 1L && grepl("[.]pdf$", f$file, ignore.case = TRUE)) saving[[f$file]] <<- list(problem = sprintf("The file holds %d pages; only a file of one page is described.", n))
+    else if (!is.null(f$pages[[n]]$recorded)) saving[[f$file]] <<- drawn_page(f$pages[[n]])
+  }
+  closed <<- list()
+  saved <- saving; saving <<- list()
+  if (!isTRUE(msg$inline) && !is.null(msg$plots)) {
+    root <- normalizePath(getwd(), winslash = "/")
+    k <- 0L
+    for (named in names(saved)) {
+      if (k >= msg$maxPlots) break
+      page <- saved[[named]]
+      if (!file.exists(named)) next
+      full <- normalizePath(named, winslash = "/")
+      if (!startsWith(full, paste0(root, "/"))) next
+      described <- if (!is.null(page$problem)) list(problem = page$problem) else if (is.function(page$env$describe_page))
+        tryCatch(page$env$describe_page(page$object, full, page$width, page$height, file.path(msg$plots, paste0(id, "-s", k + 1L, ".figure.json")), recorded = page$recorded),
+          error = function(e) list(problem = conditionMessage(e)))
+      # A page drawn on a file that no extension describes (a lattice page) stays a picture without a word.
+      if (is.null(described) && isTRUE(page$quiet)) next
+      k <- k + 1L
+      out <- list(id = id, kind = "saved", path = substring(full, nchar(root) + 2), number = k)
+      if (!is.null(described$problem)) out$figureProblem <- as.character(described$problem)[1] else if (!is.null(described)) out$figure <- described
+      say(out)
+    }
+  }
+  own_devices <<- FALSE
   say(list(id = id, kind = "done", ok = ok, interrupted = interrupted, variables = variables(msg$maxVariables),
     used = I(intersect(seen$mentioned, known)), assigned = I(seen$assigned), files = touched(files)))
 }

package/node_modules/@rho-workspace/plugin-kernel/runners/runner.py

@@ -4,7 +4,7 @@
 # that value, as a notebook does. Figures made with matplotlib are saved after each cell. An
 # interrupt (SIGINT; on Windows a Ctrl+C or Ctrl+Break on the session's console) stops the cell
 # that is running and leaves the session and its variables.
-import ast, base64, io, json, linecache, os, platform, re, signal, sys, tempfile, traceback, types
+import ast, base64, functools, io, json, linecache, os, platform, re, signal, sys, tempfile, traceback, types
 
 root = sys.argv[1]
 os.chdir(root)
@@ -67,6 +67,27 @@ def variables(most):
         items.append({'name': name, 'type': type(value).__name__, 'size': size, 'bytes': bytes_, 'summary': summary})
     return {'items': items, 'omitted': max(0, len(names) - most)}
 
+# Plugins can describe what a figure draws (RHO_KERNEL_EXTENSIONS names their Python files). Each file
+# runs in a namespace of its own; describe_figure() writes a record beside the figure's picture. One
+# that fails to load is left out, and a figure no extension describes stays a picture.
+extensions = []
+for file in os.environ.get('RHO_KERNEL_EXTENSIONS', '').split(os.pathsep):
+    if not file: continue
+    try:
+        with open(file, encoding='utf-8') as f: scope = {'__name__': 'rho_extension', '__file__': file}; exec(compile(f.read(), file, 'exec'), scope)
+        if callable(scope.get('describe_figure')): extensions.append(scope)
+    except Exception: pass
+
+# The names the running cell's code assigns, then those it reads: a describer compares those tables
+# first, a table the cell made before one it read.
+cell_names = []
+def describe(figure, into, **options):
+    for scope in extensions:
+        try: out = scope['describe_figure'](figure, into, namespace, prefer=cell_names, **options)
+        except Exception as error: return {'problem': f'{type(error).__name__}: {error}'}
+        if out is not None: return out
+    return None
+
 # A session on a server draws in its own temporary folder and sends each figure with its answer.
 def save_figures(cell, folder, most, inline=False):
     plt = sys.modules.get('matplotlib.pyplot')
@@ -81,9 +102,85 @@ def save_figures(cell, folder, most, inline=False):
             if inline:
                 with open(file, 'rb') as f: plot['data'] = base64.b64encode(f.read()).decode('ascii')
                 os.remove(file)
+            elif extensions:
+                described = describe(figure, file[:-4] + '.figure.json', bbox_inches='tight')
+                if described and described.get('problem'): plot['figureProblem'] = str(described['problem'])[:500]
+                elif described: plot['figure'] = described
             emit(plot)
     plt.close('all')
 
+# Figures the code saved to files in the project (savefig): each is described as savefig wrote it,
+# and named with its file when the cell ends, once the file is as the cell left it. A file saved twice
+# keeps its last figure. Nothing is kept for a session on a server, or for a file outside the project.
+saving = {'cell': None, 'folder': None, 'files': {}, 'most': 0}
+def saved_figure(figure, fname, kwargs):
+    import matplotlib
+    cell, folder, files = saving['cell'], saving['folder'], saving['files']
+    if not cell or not folder or not isinstance(fname, (str, os.PathLike)): return
+    full = os.path.realpath(os.path.join(os.getcwd(), os.fspath(fname)))
+    # savefig adds the format's extension to a name that has none.
+    fmt = kwargs.get('format') or matplotlib.rcParams['savefig.format']
+    if not os.path.isfile(full) and os.path.isfile(f'{full}.{fmt}'): full = f'{full}.{fmt}'
+    root = os.path.realpath(os.getcwd())
+    if not full.startswith(root + os.sep) or full.startswith(os.path.realpath(folder) + os.sep) or not os.path.isfile(full): return
+    if full not in files and len(files) >= saving['most']: return
+    pending = files[full][0] if full in files else os.path.join(folder, f'{cell}-p{len(files) + 1}.figure.json')
+    bbox = kwargs.get('bbox_inches', matplotlib.rcParams['savefig.bbox'])
+    options = {'bbox_inches': None if bbox == 'standard' else bbox, 'pad_inches': kwargs.get('pad_inches', matplotlib.rcParams['savefig.pad_inches'])}
+    files[full] = (pending, describe(figure, pending, **options))
+
+def watch_savefig(module):
+    Figure = getattr(module, 'Figure', None)
+    if Figure is None or getattr(Figure.savefig, '_rho', False): return
+    original = Figure.savefig
+    @functools.wraps(original)
+    def savefig(self, fname, *args, **kwargs):
+        result = original(self, fname, *args, **kwargs)
+        try: saved_figure(self, fname, kwargs)
+        except Exception: pass
+        return result
+    savefig._rho = True
+    Figure.savefig = savefig
+
+# matplotlib.figure is watched as it is first imported, whichever cell imports it.
+class WatchFigures:
+    def find_spec(self, name, path=None, target=None):
+        if name != 'matplotlib.figure': return None
+        for finder in sys.meta_path:
+            if finder is self or not hasattr(finder, 'find_spec'): continue
+            spec = finder.find_spec(name, path, target)
+            if spec is None: continue
+            loader = spec.loader
+            if loader is not None and hasattr(loader, 'exec_module'):
+                run = loader.exec_module
+                def exec_module(module, run=run):
+                    run(module)
+                    try: watch_savefig(module)
+                    except Exception: pass
+                loader.exec_module = exec_module
+            return spec
+        return None
+if extensions:
+    if 'matplotlib.figure' in sys.modules: watch_savefig(sys.modules['matplotlib.figure'])
+    else: sys.meta_path.insert(0, WatchFigures())
+
+def emit_saved(cell):
+    root, k = os.path.realpath(os.getcwd()), 0
+    for full, (pending, described) in saving['files'].items():
+        if not os.path.isfile(full): continue
+        k += 1
+        out = {'id': cell, 'kind': 'saved', 'path': os.path.relpath(full, root).replace(os.sep, '/'), 'number': k}
+        if described and described.get('problem'): out['figureProblem'] = str(described['problem'])[:500]
+        elif described and os.path.isfile(pending):
+            record = os.path.join(saving['folder'], f'{cell}-s{k}.figure.json')
+            os.replace(pending, record)
+            out['figure'] = dict(described, file=os.path.basename(record))
+        emit(out)
+    for pending, _ in saving['files'].values():
+        if os.path.isfile(pending):
+            try: os.remove(pending)
+            except OSError: pass
+
 # What a cell's code reads and assigns, from its parsed text before it runs: the names it loads,
 # the names it binds (also through df[...] = or obj.attr =, def, class and import), and its
 # strings. What a function, lambda or comprehension binds is its own, and so is a name the cell
@@ -210,6 +307,8 @@ def run(msg):
     name = f"<cell {msg.get('number', '')}>"
     linecache.cache[name] = (len(msg['code']), None, msg['code'].splitlines(True), name)
     sys.stdout, sys.stderr = Stream(cell, 'stdout'), Stream(cell, 'stderr')
+    if extensions and not msg.get('inline') and msg.get('plots'): saving.update(cell=cell, folder=msg['plots'], files={}, most=msg['maxPlots'])
+    cell_names[:] = list(assigned) + sorted(n for n in mentioned if n not in assigned)
     try:
         tree = ast.parse(msg['code'], name, 'exec')
         last = tree.body.pop() if tree.body and isinstance(tree.body[-1], ast.Expr) else None
@@ -227,8 +326,14 @@ def run(msg):
         emit({'id': cell, 'kind': 'error', 'text': 'Traceback (most recent call last):\n' + text if frames else text})
     finally:
         sys.stdout, sys.stderr = real_out, real_err
+    # The cell's own pictures are not files it saved.
+    saving['cell'] = None
     try: save_figures(cell, msg['plots'], msg['maxPlots'], msg.get('inline', False))
     except Exception as error: emit({'id': cell, 'kind': 'stderr', 'text': f'The figures could not be saved: {error}\n'})
+    if saving['files']:
+        try: emit_saved(cell)
+        except Exception: pass
+    saving.update(cell=None, folder=None, files={}, most=0)
     emit({'id': cell, 'kind': 'done', 'ok': ok, 'interrupted': interrupted, 'variables': variables(msg['maxVariables']),
           'used': sorted(mentioned & known), 'assigned': assigned, 'files': touched(files)})
 

package/node_modules/@rho-workspace/plugin-tables/README.md

@@ -13,6 +13,11 @@ Selected services: Only the root, bytes, resolve and register ports of Files; no
 
 Only this plugin depends on csv-parse. No scientific column assumptions or chart renderer.
 
+A CSV opened as observed is read lexically, every value as text. A column its header leaves
+unnamed is named: R's `write.csv()` and pandas' `to_csv()` write row names or the index under an
+empty header, which becomes `row`; another unnamed column becomes `column N`, and a name the
+header already uses is not taken twice.
+
 The package depends on `@rho-workspace/plugin-contracts` 0.4.0 for generic envelopes and service ports
 and ordinary file primitives; that package contains no capability implementation.
 Service ports do not install or start other plugins. Rho explicitly selects and

package/node_modules/@rho-workspace/plugin-tables/dist/index.d.ts

@@ -5,6 +5,7 @@ export declare const tableLimits: {
     maxRows: number;
     maxPageRows: number;
 };
+export declare function csvColumnNames(header: string[]): string[];
 export declare function lexicalCsvDeclaration(data: Buffer, relative: string): Declaration;
 export declare function validateTableDeclaration(d: Declaration): void;
 export declare const declarationValidator: {

package/node_modules/@rho-workspace/plugin-tables/dist/index.js

@@ -4,12 +4,28 @@ import { parse } from 'csv-parse/sync';
 import { atomicJson, canonical, confined, digest, publicResource, requireThat, stateDirectory, validateDeclarationEnvelope as validateEnvelope } from '@rho-workspace/plugin-contracts';
 const declaredSkill = (id, content, version = '1.0') => ({ id, version, content, digest: digest(content) });
 export const tableLimits = { maxRows: 100000, maxPageRows: 1000 };
+// A column a CSV leaves unnamed is named: R's write.csv() and pandas' to_csv() write row names
+// or the index under an empty header, which is "row"; another unnamed column is "column N". A name
+// the header already uses is not taken twice. The row reader names the header the same way.
+export function csvColumnNames(header) {
+    const taken = new Set(header.filter(Boolean));
+    return header.map((name, i) => {
+        if (name)
+            return name;
+        const base = i === 0 ? 'row' : `column ${i + 1}`;
+        let named = base;
+        for (let k = 2; taken.has(named); k++)
+            named = `${base} ${k}`;
+        taken.add(named);
+        return named;
+    });
+}
 // Opening an observed CSV supplies a lexical view, with no guessed numeric,
 // missing-value or entity semantics. The usual table reader validates all rows.
 export function lexicalCsvDeclaration(data, relative) {
     requireThat(data.length <= 8 * 1024 * 1024, 'limit', 'CSV preview exceeds 8 MiB.');
     const records = parse(data, { bom: true, skip_empty_lines: true, max_record_size: 1024 * 1024, to: 1 });
-    const declaration = { path: relative, kind: 'table', format: { encoding: 'csv', columns: (records[0] ?? []).map(name => ({ name, type: 'string', nullValues: [] })), key: null } };
+    const declaration = { path: relative, kind: 'table', format: { encoding: 'csv', columns: csvColumnNames(records[0] ?? []).map(name => ({ name, type: 'string', nullValues: [] })), key: null } };
     validateTableDeclaration(declaration);
     return declaration;
 }
@@ -50,7 +66,7 @@ export class Tables {
         else {
             const records = parse(data, { bom: true, skip_empty_lines: true, max_record_size: 1024 * 1024 });
             const header = records.shift() ?? [];
-            requireThat(canonical(header) === canonical(f.columns.map(c => c.name)), 'condition', 'CSV headers do not match the declared columns.');
+            requireThat(canonical(csvColumnNames(header)) === canonical(f.columns.map(c => c.name)), 'condition', 'CSV headers do not match the declared columns.');
             requireThat(records.length <= this.limits.maxRows, 'limit', 'Table exceeds the row reader budget.', { limit: 'maxRows' });
             rows = records.map(values => Object.fromEntries(f.columns.map((c, i) => {
                 const value = values[i];
@@ -160,6 +176,6 @@ const tablesSkill = {
     ],
     verify: { command: 'npm run test:tables', description: 'Declared types keep leading zeros and literal NA, joins retain nulls, namespaces and both input versions, and unkeyed tables never fabricate keys.' }
 };
-export const plugin = { entryVersion: '1.0', id: 'tables', package: '@rho-workspace/plugin-tables', version: '0.5.0', requires: ['files'], capabilities: ['tables'], presentation,
+export const plugin = { entryVersion: '1.0', id: 'tables', package: '@rho-workspace/plugin-tables', version: '0.5.2', requires: ['files'], capabilities: ['tables'], presentation,
     operations: Object.entries(operationContracts).map(([method, contract]) => ({ method, presentation: operationPresentation[method], version: '2.0', ...structuredClone(contract), requires: [...contract.requires] })), skills: [{ ...tablesSkill, presentation: skillPresentation }],
     components: [{ id: 'rho.table', version: '0.2.0', owner: 'rho-plugins.table', bindings: { data: 'table' }, ui: './ui', presentation: viewPresentation, propsSchema: { type: 'object', additionalProperties: false, properties: { title: { type: 'string', minLength: 1 } }, required: ['title'] } }] };

package/node_modules/@rho-workspace/plugin-tables/dist/ui.js

@@ -230,7 +230,7 @@ function BoundTable({ view, projectId, client, selectable = true, active, render
     return _jsxs("div", { ref: root, style: { display: 'flex', flexDirection: 'column', height: '100%', minHeight: 0 }, children: [_jsxs("div", { style: bar, role: "toolbar", "aria-label": "Table", children: [_jsx("span", { children: count }), selected > 0 && _jsxs("span", { children: ["\u00B7 ", selected, " selected"] }), selected > 0 && requestFeedback && _jsx("button", { style: control, onClick: () => { void selectionQueue.current.then(() => { if (selectionConfirmed.current)
                             requestFeedback();
                         else
-                            setFailure('Confirm the selected rows before asking Claude Code.'); }); }, children: "Ask Claude Code" }), filter && _jsxs("span", { style: { ...control, display: 'inline-flex', gap: 6, alignItems: 'center' }, children: [filter.column, " ", opLabel[filter.op], filter.op !== 'isNull' && ' ' + String(filter.value), _jsx("button", { "aria-label": "Remove filter", style: { border: 'none', background: 'none', cursor: 'pointer', padding: 0, color: 'inherit' }, onClick: () => applyFilter(null), children: "\u00D7" })] }), !filter && meta && !draft && _jsx("button", { style: control, onClick: () => setDraft({ column: meta.columns[0].name, op: 'eq', value: '' }), children: "Filter" }), draft && meta && _jsxs("form", { style: { display: 'flex', gap: 6, flexWrap: 'wrap', maxWidth: '100%' }, onSubmit: e => { e.preventDefault(); submitDraft(); }, children: [_jsx("select", { "aria-label": "Column", style: control, value: draft.column, onChange: e => setDraft({ ...draft, column: e.target.value, op: 'eq', value: '' }), children: meta.columns.map(c => _jsx("option", { children: c.name }, c.name)) }), _jsx("select", { "aria-label": "Condition", style: control, value: draft.op, onChange: e => setDraft({ ...draft, op: e.target.value }), children: Object.keys(opLabel).filter(op => !(['lt', 'gt'].includes(op) && meta.columns.find(c => c.name === draft.column)?.type === 'boolean')).map(op => _jsx("option", { value: op, children: opLabel[op] }, op)) }), draft.op !== 'isNull' && _jsx("input", { "aria-label": "Value", style: control, value: draft.value, onChange: e => setDraft({ ...draft, value: e.target.value }) }), _jsx("button", { style: control, type: "submit", children: "Apply" }), _jsx("button", { style: control, type: "button", onClick: () => setDraft(null), children: "Cancel" })] }), meta && !meta.entityKey && selectable && _jsx("span", { style: { color: 'var(--text-muted, #5f6873)' }, children: "Rows have no key, so they can't be selected for Claude Code." })] }), failure && _jsxs("div", { role: "alert", style: { ...bar, color: 'var(--danger, #cf222e)' }, children: [failure, _jsx("button", { style: control, onClick: () => { setAttempt(n => n + 1); api.current?.purgeInfiniteCache(); }, children: "Try again" })] }), observationFailure && _jsx("div", { role: "status", style: bar, children: observationFailure }), _jsx("div", { style: { flex: 1, minHeight: 0, maskImage: more ? 'linear-gradient(to right, #000 calc(100% - 48px), transparent)' : undefined }, children: meta && _jsx(AgGridReact, { theme: theme, rowModelType: "infinite", datasource: datasource, cacheBlockSize: pageRows, maxBlocksInCache: 5, suppressMultiSort: true, maxConcurrentDatasourceRequests: 1, columnDefs: columnDefs, 
+                            setFailure('Confirm the selected rows before asking the Agent.'); }); }, children: "Ask Agent" }), filter && _jsxs("span", { style: { ...control, display: 'inline-flex', gap: 6, alignItems: 'center' }, children: [filter.column, " ", opLabel[filter.op], filter.op !== 'isNull' && ' ' + String(filter.value), _jsx("button", { "aria-label": "Remove filter", style: { border: 'none', background: 'none', cursor: 'pointer', padding: 0, color: 'inherit' }, onClick: () => applyFilter(null), children: "\u00D7" })] }), !filter && meta && !draft && _jsx("button", { style: control, onClick: () => setDraft({ column: meta.columns[0].name, op: 'eq', value: '' }), children: "Filter" }), draft && meta && _jsxs("form", { style: { display: 'flex', gap: 6, flexWrap: 'wrap', maxWidth: '100%' }, onSubmit: e => { e.preventDefault(); submitDraft(); }, children: [_jsx("select", { "aria-label": "Column", style: control, value: draft.column, onChange: e => setDraft({ ...draft, column: e.target.value, op: 'eq', value: '' }), children: meta.columns.map(c => _jsx("option", { children: c.name }, c.name)) }), _jsx("select", { "aria-label": "Condition", style: control, value: draft.op, onChange: e => setDraft({ ...draft, op: e.target.value }), children: Object.keys(opLabel).filter(op => !(['lt', 'gt'].includes(op) && meta.columns.find(c => c.name === draft.column)?.type === 'boolean')).map(op => _jsx("option", { value: op, children: opLabel[op] }, op)) }), draft.op !== 'isNull' && _jsx("input", { "aria-label": "Value", style: control, value: draft.value, onChange: e => setDraft({ ...draft, value: e.target.value }) }), _jsx("button", { style: control, type: "submit", children: "Apply" }), _jsx("button", { style: control, type: "button", onClick: () => setDraft(null), children: "Cancel" })] }), meta && !meta.entityKey && selectable && _jsx("span", { style: { color: 'var(--text-muted, #5f6873)' }, children: "This table has no row key; row selection is unavailable." })] }), failure && _jsxs("div", { role: "alert", style: { ...bar, color: 'var(--danger, #cf222e)' }, children: [failure, _jsx("button", { style: control, onClick: () => { setAttempt(n => n + 1); api.current?.purgeInfiniteCache(); }, children: "Try again" })] }), observationFailure && _jsx("div", { role: "status", style: bar, children: observationFailure }), _jsx("div", { style: { flex: 1, minHeight: 0, maskImage: more ? 'linear-gradient(to right, #000 calc(100% - 48px), transparent)' : undefined }, children: meta && _jsx(AgGridReact, { theme: theme, rowModelType: "infinite", datasource: datasource, cacheBlockSize: pageRows, maxBlocksInCache: 5, suppressMultiSort: true, maxConcurrentDatasourceRequests: 1, columnDefs: columnDefs, 
                     // Columns take their contents' width, headers included, so a number is never cut to
                     // an ellipsis that hides its exponent; a wide table scrolls sideways instead.
                     defaultColDef: { resizable: true, minWidth: 64 }, suppressColumnVirtualisation: (meta?.columns.length ?? 0) <= 40, onFirstDataRendered: fitColumns, getRowId: meta?.entityKey && meta.namespace ? p => meta.namespace + ':' + String(p.data[meta.entityKey]) : undefined, rowSelection: meta?.entityKey && meta.namespace && selectable ? { mode: 'multiRow', checkboxes: true, headerCheckbox: false, enableClickSelection: true } : undefined, onModelUpdated: e => { if (meta.entityKey)

package/node_modules/@rho-workspace/plugin-tables/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rho-workspace/plugin-tables",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "type": "module",
   "description": "Rho tables plugin",
   "license": "AGPL-3.0-only",

package/node_modules/hono/dist/adapter/aws-lambda/handler.js

@@ -199,7 +199,7 @@ var EventV2Processor = class extends EventProcessor {
 		const headers = new Headers();
 		this.getCookies(event, headers);
 		if (event.headers) {
-			for (const [k, v] of Object.entries(event.headers)) if (v) headers.set(k, v);
+			for (const [k, v] of Object.entries(event.headers)) if (v) headers.set(k, sanitizeHeaderValue(v));
 		}
 		return headers;
 	}