@rho-workspace/rho 0.5.5 → 0.5.7

package/node_modules/@rho-workspace/plugin-figures/dist/operations.js

@@ -0,0 +1,39 @@
+import { objectSchema as obj, text } from '@rho-workspace/plugin-contracts';
+// Owner business contracts. Application project/authentication fields are separate.
+// A figure is named by the Notebook cell that drew it and the plot's number in that cell, or, for a
+// plot a cell saved to a project file (ggsave), by the file: its path, read as it is now, or the
+// SHA-256 of its bytes. A mark is "L.M": layer L of the figure, built row M of that layer, both
+// counted from 0.
+const cellId = { type: 'string', pattern: '^k-[a-f0-9]{16}$' };
+const plot = { type: 'integer', minimum: 1, maximum: 64 };
+const filePath = { type: 'string', minLength: 1, maxLength: 512 };
+const sha256 = { type: 'string', pattern: '^[a-f0-9]{64}$' };
+const mark = { type: 'string', pattern: '^\\d{1,4}\\.\\d{1,7}$' };
+export const selectionId = { type: 'string', pattern: '^f-[a-f0-9]{16}$' };
+const changeId = { type: 'string', pattern: '^[A-Za-z0-9._:@-]{1,128}$' };
+const cell = { anyOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }, { type: 'null' }] };
+const where = obj({ column: { type: 'string', minLength: 1, maxLength: 256 }, op: { enum: ['eq', 'ne', 'lt', 'le', 'gt', 'ge', 'in', 'contains'] }, value: { anyOf: [cell, { type: 'array', items: cell, maxItems: 500 }] }, layer: { type: 'integer', minimum: 0 } }, ['column', 'op', 'value']);
+export const selectionSchema = obj({
+    selectionId, cellId, plot, path: filePath, sha256, digest: { type: 'string', pattern: '^[a-f0-9]{64}$' }, by: text, at: text, changeId, note: { type: 'string' },
+    count: { type: 'integer', minimum: 0 }, layers: { type: 'array', items: obj({ layer: { type: 'integer', minimum: 0 }, geom: { type: 'string' }, marks: { type: 'integer', minimum: 0 } }) },
+    marks: { type: 'array', items: mark },
+}, ['selectionId', 'cellId', 'digest', 'by', 'at', 'changeId', 'note', 'count', 'layers']);
+export const operationContracts = {
+    // summary (the default) says what was drawn; view adds the whole record a page draws from;
+    // selections reads only the kept selections, with their marks.
+    // marks, selection or where name marks whose rows to return, at most limit of them.
+    'figure.read': {
+        inputSchema: obj({ cellId, plot, path: filePath, sha256, form: { enum: ['summary', 'view', 'selections'] }, marks: { type: 'array', items: mark, maxItems: 5000 }, selection: selectionId,
+            where: { type: 'array', items: where, minItems: 1, maxItems: 8 }, limit: { type: 'integer', minimum: 1, maximum: 500 } }, []),
+        outputSchema: obj({ figure: { type: 'object' }, summary: { type: 'object' }, record: { type: 'object' }, selections: { type: 'array', items: selectionSchema },
+            rows: { type: 'array', items: { type: 'object' } }, rowsTotal: { type: 'integer', minimum: 0 }, matched: { type: 'object' } }, ['figure', 'selections']),
+        requires: [], effect: 'read',
+    },
+    // Keeps a set of marks with a note, by whoever chose them: the person's selection that goes with a
+    // message, or the marks an Agent points the person to. It changes neither the plot nor its data.
+    'figure.select': {
+        inputSchema: obj({ cellId, plot, path: filePath, sha256, marks: { type: 'array', items: mark, minItems: 1, maxItems: 5000 }, note: { type: 'string', maxLength: 500 }, changeId }, ['marks', 'changeId']),
+        outputSchema: obj({ selection: selectionSchema }),
+        requires: [], effect: 'metadata',
+    },
+};

package/node_modules/@rho-workspace/plugin-figures/dist/presentation.d.ts

@@ -0,0 +1,19 @@
+import type { EntryPresentation, PluginPresentation } from '@rho-workspace/plugin-contracts';
+export declare const presentation: PluginPresentation;
+export declare const operationPresentation: {
+    'figure.read': {
+        order: number;
+        displayName: string;
+        description: string;
+        readOnly: true;
+        runsCode: false;
+    };
+    'figure.select': {
+        order: number;
+        displayName: string;
+        description: string;
+        readOnly: false;
+        runsCode: false;
+    };
+};
+export declare const skillPresentation: EntryPresentation;

package/node_modules/@rho-workspace/plugin-figures/dist/presentation.js

@@ -0,0 +1,26 @@
+export const presentation = {
+    categoryOrder: 20,
+    order: 15,
+    description: "A ggplot drawn in the project's live R session, by you or the Agent, is kept with every point, bar, box, line and label bound to the row of data it was drawn from. It works for any plot built on ggplot2 (ggtree, enrichplot, Seurat, patchwork and the rest) with no setup. Point at a mark to read its row, select marks by clicking or dragging, and ask the Agent about them: your message carries the exact rows. The Agent reads what a plot actually drew and can mark points for you with a note.",
+    icon: { "background": "#E8F2EE", "color": "#2F6B57", "paths": ["M4.5 19.5h15", "M4.5 19.5v-15", "M8 15.5a1.25 1.25 0 1 0 0-.01", "M12 10.5a1.25 1.25 0 1 0 0-.01", "M16.5 13a1.25 1.25 0 1 0 0-.01", "M14.5 6.5h5v5h-5z"] },
+    dependencies: [{ "pluginId": "kernel", "purpose": "to describe the plots its live R session draws" }],
+    developer: "Rho",
+    license: "AGPL-3.0-only",
+    links: [{ "label": "Source", "url": "https://github.com/YuLab-SMU/Rho-plugins/tree/main/plugins/figures" }, { "label": "Privacy", "url": "https://github.com/YuLab-SMU/Rho-plugins/blob/main/PRIVACY.md" }],
+    displayName: 'Figures',
+    tagline: 'Plots whose marks know their data',
+    category: 'Figures & media',
+    examplePrompts: [
+        '“Draw the volcano plot in the notebook; I will select the genes I care about.”',
+        '“What do the points I selected have in common?”',
+        '“Mark the genes in this plot with padj below 0.01 and say why they stand out.”',
+        '“Did the last plot drop any rows? Check what it actually drew.”',
+    ],
+    viewNote: 'In the Notebook and Plots, on every ggplot',
+    readOnly: false, runsCode: false,
+};
+export const operationPresentation = {
+    'figure.read': { order: 10, displayName: 'Read a figure', description: "Reads what a plot drew: its layers, mappings, panels and data, the rows behind marks, and the marks people selected.", readOnly: true, runsCode: false },
+    'figure.select': { order: 20, displayName: 'Mark points in a figure', description: "Keeps a set of marks with a note, shown highlighted in the plot. It changes neither the plot nor its data.", readOnly: false, runsCode: false },
+};
+export const skillPresentation = { displayName: 'Figures', description: 'Teaches the Agent to read what a plot drew, the rows behind its marks and the person\'s selections, and to point at marks.' };

package/node_modules/@rho-workspace/plugin-figures/dist/record.d.ts

@@ -0,0 +1,188 @@
+export type Cell = string | number | boolean | null;
+export interface FigureColumn {
+    name: string;
+    type: 'number' | 'integer' | 'text' | 'logical' | 'list';
+    values: Cell[];
+}
+export interface FigureSource {
+    id: string;
+    rows: number;
+    columnsTotal: number;
+    key: string | null;
+    index: number[];
+    columns: FigureColumn[];
+}
+export interface FigureLayer {
+    plot: number;
+    layer: number;
+    geom: string;
+    stat: string;
+    position: string;
+    mapping: Record<string, string>;
+    constants: Record<string, string | number>;
+    source: string | null;
+    marks: number;
+    units: number;
+    bound: 'mark' | 'group' | 'none';
+    unbound?: string[];
+    notes?: string[];
+}
+export interface FigureMarks {
+    panel: number[];
+    group: number[];
+    row: number[] | null;
+    columns: FigureColumn[];
+}
+export interface FigureUnit {
+    layer: number;
+    panel: number;
+    marks: number[][];
+}
+export interface FigureScale {
+    aesthetic: string;
+    title: string;
+    breaks: string[];
+    values: string[];
+}
+export interface FigurePlot {
+    plot: number;
+    title?: string | null;
+    subtitle?: string | null;
+    caption?: string | null;
+    labels: Record<string, string>;
+    panels: Array<{
+        panel: number;
+        facets: Record<string, string>;
+    }>;
+    facet: string;
+    coord: string;
+    scales: FigureScale[];
+    positions: Partial<Record<'x' | 'y', {
+        discrete: boolean;
+        levels?: string[];
+        range?: number[];
+    }>>;
+}
+export interface FigureRecord {
+    schema: 'rho.figure/1';
+    describer: string;
+    size: {
+        width: number;
+        height: number;
+        units: string;
+    };
+    versions: Record<string, string>;
+    seconds: number;
+    svg: string;
+    problems: string[];
+    units: FigureUnit[];
+    figure: {
+        kind: string;
+        title?: string | null;
+        plots: FigurePlot[];
+        layers: FigureLayer[];
+    };
+    marks: FigureMarks[];
+    sources: FigureSource[];
+}
+export declare function parseRecord(bytes: Uint8Array | string): FigureRecord;
+export interface MarkRef {
+    layer: number;
+    mark: number;
+}
+export declare const markName: (m: MarkRef) => string;
+export declare function parseMark(name: string): MarkRef | null;
+export declare function elementMarks(record: FigureRecord, attribute: string): MarkRef[];
+export interface MarkRow {
+    mark: string;
+    layer: number;
+    geom: string;
+    plot: number;
+    facets: Record<string, string>;
+    built: Record<string, Cell>;
+    source?: string;
+    row?: number;
+    key?: {
+        column: string;
+        value: Cell;
+    };
+    values?: Record<string, Cell>;
+}
+export declare function markRow(record: FigureRecord, ref: MarkRef): MarkRow | null;
+export type Op = 'eq' | 'ne' | 'lt' | 'le' | 'gt' | 'ge' | 'in' | 'contains';
+export interface Where {
+    column: string;
+    op: Op;
+    value: Cell | Cell[];
+    layer?: number;
+}
+export declare function matchMarks(record: FigureRecord, where: Where[], maximum: number): {
+    marks: MarkRef[];
+    total: number;
+};
+export declare function figureSummary(record: FigureRecord): {
+    describer: string;
+    kind: string;
+    title: string | null;
+    size: {
+        width: number;
+        height: number;
+        units: string;
+    };
+    versions: Record<string, string>;
+    plots: {
+        plot: number;
+        title: string | null;
+        subtitle: string | null;
+        labels: Record<string, string>;
+        facet: string;
+        coord: string;
+        panels: number;
+        facets: Record<string, string>[] | undefined;
+        scales: {
+            aesthetic: string;
+            title: string;
+            breaks: string[];
+        }[];
+        positions: {
+            [k: string]: {
+                discrete: boolean;
+                levels: string[] | undefined;
+                levelCount: number | undefined;
+                range?: undefined;
+            } | {
+                discrete: boolean;
+                range: number[] | undefined;
+                levels?: undefined;
+                levelCount?: undefined;
+            };
+        };
+    }[];
+    layers: {
+        builtColumns: string[];
+        notes?: string[] | undefined;
+        notBound?: string[] | undefined;
+        layer: number;
+        plot: number;
+        geom: string;
+        stat: string;
+        position: string;
+        mapping: Record<string, string>;
+        constants: Record<string, string | number>;
+        source: string | null;
+        marks: number;
+        bound: "mark" | "group" | "none";
+    }[];
+    sources: {
+        id: string;
+        rows: number;
+        rowsWithMarks: number;
+        key: string | null;
+        columns: {
+            name: string;
+            type: "number" | "integer" | "text" | "logical" | "list";
+        }[];
+        columnsTotal: number;
+    }[];
+    problems: string[];
+};

package/node_modules/@rho-workspace/plugin-figures/dist/record.js

@@ -0,0 +1,143 @@
+// A figure record as an R describer wrote it (r/figures.R): the picture as SVG whose drawn
+// elements name the marks they stand for, each layer's built marks, and the rows of the plot's
+// data those marks came from. Nothing here interprets a plot; it reads what was bound.
+//
+// A mark is named "L.M": layer L of the figure (counted from 0 over every plot of a
+// composition) and built row M of that layer (from 0). A drawn element of unit U names itself
+// data-rho="U.E": element E of the unit stands for the marks the unit lists at E (one row, or a
+// group such as one box or one line).
+// jsonlite writes a list or an empty named list as [], and some vectors of one as a scalar.
+const list = (v) => Array.isArray(v) ? v : v === null || v === undefined ? [] : [v];
+const named = (v) => v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+const columns = (v) => list(v).map(c => ({ name: String(c.name), type: c.type, values: list(c.values) }));
+export function parseRecord(bytes) {
+    const raw = JSON.parse(typeof bytes === 'string' ? bytes : new TextDecoder().decode(bytes));
+    if (raw?.schema !== 'rho.figure/1' || typeof raw.svg !== 'string')
+        throw new Error('This is not a figure record this version reads.');
+    return {
+        ...raw, problems: list(raw.problems),
+        units: list(raw.units).map(u => ({ layer: u.layer, panel: u.panel, marks: list(u.marks).map(m => list(m)) })),
+        figure: {
+            ...raw.figure,
+            plots: list(raw.figure?.plots).map(p => ({ ...p, labels: named(p.labels), panels: list(p.panels).map(x => ({ panel: x.panel, facets: named(x.facets) })),
+                scales: list(p.scales).map(s => ({ ...s, breaks: list(s.breaks), values: list(s.values) })), positions: named(p.positions) })),
+            layers: list(raw.figure?.layers).map(l => ({ ...l, mapping: named(l.mapping), constants: named(l.constants), unbound: l.unbound ? list(l.unbound) : undefined, notes: l.notes ? list(l.notes) : undefined })),
+        },
+        marks: list(raw.marks).map(m => ({ panel: list(m.panel), group: list(m.group), row: m.row === null || m.row === undefined ? null : list(m.row), columns: columns(m.columns) })),
+        sources: list(raw.sources).map(s => ({ ...s, key: s.key ?? null, index: list(s.index), columns: columns(s.columns) })),
+    };
+}
+export const markName = (m) => `${m.layer}.${m.mark}`;
+export function parseMark(name) {
+    const m = /^(\d{1,4})\.(\d{1,7})$/.exec(name);
+    return m ? { layer: Number(m[1]), mark: Number(m[2]) } : null;
+}
+// The marks one drawn element stands for.
+export function elementMarks(record, attribute) {
+    const m = /^(\d+)\.(\d+)$/.exec(attribute);
+    if (!m)
+        return [];
+    const unit = record.units[Number(m[1])];
+    return (unit?.marks[Number(m[2])] ?? []).map(mark => ({ layer: unit.layer, mark }));
+}
+// The source row a mark came from, as its position in the source and in the kept rows.
+function sourceRow(record, ref) {
+    const layer = record.figure.layers[ref.layer], marks = record.marks[ref.layer];
+    if (!layer?.source || !marks?.row)
+        return null;
+    const source = record.sources.find(s => s.id === layer.source);
+    const row = marks.row[ref.mark];
+    if (!source || row === undefined)
+        return null;
+    // index is sorted: the rows of the source that some mark stands for.
+    let lo = 0, hi = source.index.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1, v = source.index[mid];
+        if (v === row)
+            return { source, row, at: mid };
+        if (v < row)
+            lo = mid + 1;
+        else
+            hi = mid - 1;
+    }
+    return { source, row, at: -1 };
+}
+const valueAt = (column, at) => at >= 0 ? column.values[at] ?? null : null;
+export function markRow(record, ref) {
+    const layer = record.figure.layers[ref.layer], marks = record.marks[ref.layer];
+    if (!layer || !marks || ref.mark < 0 || ref.mark >= layer.marks)
+        return null;
+    const plot = record.figure.plots.find(p => p.plot === layer.plot);
+    const panel = marks.panel[ref.mark];
+    const facets = plot?.panels.find(p => p.panel === panel)?.facets ?? {};
+    const built = {};
+    for (const c of marks.columns) {
+        let v = c.values[ref.mark] ?? null;
+        const axis = c.name === 'x' || c.name === 'y' ? plot?.positions[c.name] : undefined;
+        if (axis?.discrete && typeof v === 'number' && Number.isInteger(v) && axis.levels?.[v - 1] !== undefined)
+            v = axis.levels[v - 1];
+        built[c.name] = v;
+    }
+    const out = { mark: markName(ref), layer: ref.layer, geom: layer.geom, plot: layer.plot, facets, built };
+    const found = sourceRow(record, ref);
+    if (found) {
+        out.source = found.source.id;
+        out.row = found.row;
+        out.values = Object.fromEntries(found.source.columns.map(c => [c.name, valueAt(c, found.at)]));
+        if (found.source.key)
+            out.key = { column: found.source.key, value: out.values[found.source.key] ?? null };
+    }
+    return out;
+}
+export function matchMarks(record, where, maximum) {
+    const test = (v, w) => {
+        if (w.op === 'in')
+            return Array.isArray(w.value) && w.value.some(x => x === v || String(x) === String(v));
+        const target = w.value;
+        if (w.op === 'contains')
+            return v !== null && String(v).toLowerCase().includes(String(target).toLowerCase());
+        if (w.op === 'eq')
+            return v === target || (v !== null && target !== null && String(v) === String(target));
+        if (w.op === 'ne')
+            return !(v === target || (v !== null && target !== null && String(v) === String(target)));
+        if (v === null || target === null)
+            return false;
+        const a = typeof v === 'number' ? v : Number(v), b = typeof target === 'number' ? target : Number(target);
+        if (Number.isNaN(a) || Number.isNaN(b))
+            return false;
+        return w.op === 'lt' ? a < b : w.op === 'le' ? a <= b : w.op === 'gt' ? a > b : a >= b;
+    };
+    const found = [];
+    let total = 0;
+    const layers = record.figure.layers.map((_, i) => i).filter(i => where.every(w => w.layer === undefined || w.layer === i));
+    for (const layer of layers) {
+        const n = record.figure.layers[layer].marks;
+        for (let mark = 0; mark < n; mark++) {
+            const row = markRow(record, { layer, mark });
+            if (!row)
+                continue;
+            const read = (column) => row.values && column in row.values ? row.values[column] : column in row.built ? row.built[column] : undefined;
+            if (where.every(w => { const v = read(w.column); return v !== undefined && test(v, w); })) {
+                total++;
+                if (found.length < maximum)
+                    found.push({ layer, mark });
+            }
+        }
+    }
+    return { marks: found, total };
+}
+// The figure as an Agent reads it first: what was drawn, from which data, and what was not bound.
+export function figureSummary(record) {
+    return {
+        describer: record.describer, kind: record.figure.kind, title: record.figure.title ?? null, size: record.size, versions: record.versions,
+        plots: record.figure.plots.map(p => ({ plot: p.plot, title: p.title ?? null, subtitle: p.subtitle ?? null, labels: p.labels, facet: p.facet, coord: p.coord,
+            panels: p.panels.length, facets: p.panels.length > 1 ? p.panels.slice(0, 24).map(x => x.facets) : undefined,
+            scales: p.scales.map(s => ({ aesthetic: s.aesthetic, title: s.title, breaks: s.breaks.slice(0, 24) })),
+            positions: Object.fromEntries(Object.entries(p.positions).map(([k, v]) => [k, v?.discrete ? { discrete: true, levels: v.levels?.slice(0, 48), levelCount: v.levels?.length } : { discrete: false, range: v?.range }])) })),
+        layers: record.figure.layers.map((l, i) => ({ layer: i, plot: l.plot, geom: l.geom, stat: l.stat, position: l.position, mapping: l.mapping, constants: l.constants,
+            source: l.source, marks: l.marks, bound: l.bound, ...(l.unbound?.length ? { notBound: l.unbound } : {}), ...(l.notes?.length ? { notes: l.notes } : {}),
+            builtColumns: record.marks[i]?.columns.map(c => c.name) ?? [] })),
+        sources: record.sources.map(s => ({ id: s.id, rows: s.rows, rowsWithMarks: s.index.length, key: s.key, columns: s.columns.map(c => ({ name: c.name, type: c.type })), columnsTotal: s.columnsTotal })),
+        problems: record.problems,
+    };
+}

package/node_modules/@rho-workspace/plugin-figures/dist/ui-styles.d.ts

@@ -0,0 +1 @@
+export declare function ensureFigureStyles(): void;

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

@@ -0,0 +1,68 @@
+// The figure's own styles, in the application's tokens. Highlights override the inline styles the
+// R device writes on each element, so they carry !important.
+const styles = `/* A figure whose marks are bound to their rows. */
+.fig { display: flex; flex-direction: column; gap: 8px; min-width: 0; }
+.fig-canvas { position: relative; line-height: 0; user-select: none; -webkit-user-select: none; touch-action: none; cursor: crosshair; border-radius: 6px; }
+.fig-canvas svg { display: block; width: 100%; height: auto; }
+.fig.fit { height: 100%; }
+.fig.fit .fig-canvas { flex: 1 1 auto; min-height: 0; display: flex; align-items: center; justify-content: center; }
+.fig.fit .fig-canvas svg { width: 100%; height: 100%; }
+/* Dimming changes paint, not opacity: an opacity on each of thousands of marks makes each its own layer. */
+.fig-canvas [data-rho] { cursor: pointer; }
+.fig-canvas.has-sel [data-rho]:not(.fig-on):not(.fig-tile) { fill-opacity: .13 !important; stroke-opacity: .13 !important; }
+.fig-canvas [data-rho].fig-tile.fig-on { stroke-width: 2.2px !important; }
+.fig-canvas [data-rho].fig-on { stroke: var(--color-accent-strong) !important; stroke-width: 1.6px !important; stroke-opacity: 1 !important; }
+.fig-canvas text[data-rho].fig-on { fill: var(--color-accent-strong) !important; stroke: none !important; font-weight: 700; }
+.fig-canvas [data-rho].fig-hover { stroke: var(--color-ink) !important; stroke-width: 1.4px !important; fill-opacity: 1 !important; stroke-opacity: 1 !important; }
+.fig-canvas.agent [data-rho].fig-on { stroke: var(--color-amber-text) !important; }
+.fig-canvas.agent text[data-rho].fig-on { fill: var(--color-amber-text) !important; stroke: none !important; }
+.fig-canvas.arrived [data-rho].fig-on { animation: fig-arrive .9s ease-out 1; }
+@keyframes fig-arrive { 0% { stroke-width: 6px; } 100% { stroke-width: 1.6px; } }
+@media (prefers-reduced-motion: reduce) { .fig-canvas.arrived [data-rho].fig-on { animation: none; } }
+.fig-brush { position: absolute; border: 1px solid var(--color-accent); background: color-mix(in srgb, var(--color-accent) 10%, transparent); pointer-events: none; border-radius: 2px; }
+.fig-tip { position: absolute; z-index: 6; max-width: 280px; padding: 8px 10px; border-radius: 8px; background: var(--color-surface); color: var(--color-ink);
+  border: 1px solid var(--color-hairline-strong); box-shadow: 0 6px 22px rgba(15, 23, 42, .14); pointer-events: none; line-height: 1.35; font-size: 12px; }
+.fig-tip b { display: block; font-size: 13px; font-weight: 650; overflow-wrap: anywhere; }
+.fig-tip small { display: block; color: var(--color-meta); margin-bottom: 4px; }
+.fig-tip dl { display: grid; grid-template-columns: auto minmax(0, 1fr); gap: 1px 10px; margin: 4px 0 0; }
+.fig-tip dt { color: var(--color-meta); white-space: nowrap; }
+.fig-tip dd { margin: 0; font-family: var(--font-mono); font-size: 11.5px; overflow-wrap: anywhere; }
+.fig-hint { margin: 0; color: var(--color-meta); font-size: 12px; line-height: 1.4; }
+.fig-hint b { color: var(--color-ink); font-weight: 600; }
+
+/* Marks an Agent pointed to, with its note. */
+.fig-marks { display: flex; flex-wrap: wrap; gap: 6px; }
+.fig-mark-chip { display: inline-flex; align-items: center; gap: 6px; max-width: 100%; min-height: 26px; padding: 3px 10px; border-radius: 999px; border: 1px solid var(--color-amber-line);
+  background: var(--color-amber-soft); color: var(--color-ink); font: 12px var(--font-ui); text-align: left; cursor: pointer; }
+.fig-mark-chip[aria-pressed="true"] { border-color: var(--color-amber-text); box-shadow: inset 0 0 0 1px var(--color-amber-text); }
+.fig-mark-chip span { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.fig-mark-chip strong { font-weight: 650; white-space: nowrap; }
+
+/* What is selected: the rows behind it, and asking about it. */
+.fig-sel { display: flex; flex-direction: column; gap: 6px; padding: 10px 12px; border-radius: 8px; border: 1px solid var(--color-hairline); background: var(--color-well); line-height: 1.4; }
+.fig-sel.agent { border-color: var(--color-amber-line); background: var(--color-amber-soft); }
+.fig-sel-head { display: flex; flex-wrap: wrap; align-items: center; gap: 6px 10px; }
+.fig-sel-head h4 { margin: 0; font-size: 13px; font-weight: 650; color: var(--color-ink); }
+.fig-sel-head p { margin: 0; flex: 1 1 12rem; min-width: 0; color: var(--color-meta); font-size: 12px; }
+.fig-sel-actions { display: flex; gap: 6px; margin-left: auto; }
+.fig-sel-note { margin: 0; font-size: 13px; color: var(--color-ink); }
+.fig-table-wrap { overflow: auto; max-height: 240px; border-radius: 6px; border: 1px solid var(--color-hairline); background: var(--color-surface); }
+.fig-table { border-collapse: collapse; width: max-content; min-width: 100%; font-size: 12px; }
+.fig-table th, .fig-table td { padding: 4px 10px; text-align: left; white-space: nowrap; border-bottom: 1px solid var(--color-hairline); }
+.fig-table th { position: sticky; top: 0; background: var(--color-surface); color: var(--color-meta); font-weight: 600; }
+.fig-table td { font-family: var(--font-mono); font-size: 11.5px; color: var(--color-ink); max-width: 18rem; overflow: hidden; text-overflow: ellipsis; }
+.fig-table td.num { text-align: right; font-variant-numeric: tabular-nums; }
+.fig-table tr:last-child td { border-bottom: 0; }
+.fig-more { margin: 0; color: var(--color-meta); font-size: 12px; }
+.fig-note { margin: 0; color: var(--color-meta); font-size: 12px; }
+`;
+let added = false;
+export function ensureFigureStyles() {
+    if (added || typeof document === 'undefined')
+        return;
+    added = true;
+    const style = document.createElement('style');
+    style.dataset.owner = 'rho-plugins.figures';
+    style.textContent = styles;
+    document.head.appendChild(style);
+}

package/node_modules/@rho-workspace/plugin-figures/dist/ui.d.ts

@@ -0,0 +1,56 @@
+import { type ReactNode } from 'react';
+export interface UiClient {
+    call(method: string, input: any, signal?: AbortSignal): Promise<any>;
+}
+export interface FigureSelection {
+    selectionId: string;
+    by: string;
+    at: string;
+    note: string;
+    count: number;
+    layers: Array<{
+        layer: number;
+        geom: string;
+        marks: number;
+    }>;
+    marks?: string[];
+}
+export interface FigureFile {
+    path?: string;
+    sha256: string;
+}
+export interface FigureAsk {
+    selectionId: string;
+    cellId?: string;
+    plot?: number;
+    file?: FigureFile;
+    count: number;
+    label: string;
+}
+export interface FigureProps {
+    client: UiClient;
+    projectId: string;
+    cellId?: string;
+    plot?: number;
+    file?: FigureFile;
+    width?: number;
+    height?: number;
+    label: string;
+    name?: string;
+    fit?: boolean;
+    fallback?: ReactNode;
+    cursor?: number;
+    author?: (by: string) => {
+        name: string;
+        mine: boolean;
+    };
+    onAsk?: (ask: FigureAsk) => void;
+}
+export declare const figureViewLimits: {
+    tableRows: number;
+    tableColumns: number;
+    tipColumns: number;
+    brushPx: number;
+    cachedRecords: number;
+};
+export declare function SemanticFigure({ client, projectId, cellId, plot, file, width, label, name, fit, fallback, cursor, author, onAsk }: FigureProps): import("react").JSX.Element;