dsh-molbio-tools 0.22.2 → 0.24.1

package/benchmark/tasks/02-primers.json

@@ -89,7 +89,7 @@
       "covers": [
         "molbio_design_intron_primers"
       ],
-      "instruction": "I need a qPCR assay that will NOT amplify contaminating genomic DNA. Here is the genomic sequence and the two exon coordinates — design a pair where the forward primer spans the exon-exon junction. Tell me the spliced amplicon size and how far apart the primers sit on the genome.\n\n{seq:intron_genomic}\n\nExons: 1-400 and 701-1100 (1-based).",
+      "instruction": "I need a qPCR assay that will NOT amplify contaminating genomic DNA. Here is the genomic sequence and the two exon coordinates — design a pair where one primer spans the exon-exon junction (report which one it is). Tell me the spliced amplicon size and how far apart the primers sit on the genome.\n\n{seq:intron_genomic}\n\nExons: 1-400 and 701-1100 (1-based).",
       "timeout_ms": 300000,
       "expect_tools": [
         "molbio_design_intron_primers"
@@ -97,8 +97,8 @@
       "assertions": [
         {
           "where": "tool",
-          "pattern": "forward primer spans an exon-exon junction",
-          "note": "the property that makes the assay genomic-DNA-proof"
+          "pattern": "REVERSE primer spans an exon-exon junction",
+          "note": "the property that makes the assay genomic-DNA-proof; since 0.23.0 the junction is carried by the reverse primer (the assay sits 5' of the junction), and the forward primer is upstream"
         },
         {
           "where": "tool",

package/benchmark/tasks/06-analysis.json

@@ -1,6 +1,7 @@
 {
   "$comment": [
-    "Protein analysis, bench analysis and plotting.",
+    "Protein analysis, bench analysis and plotting, plus the embedded-signature",
+    "contamination screen (short signatures, both strands, negative != clean).",
     "",
     "`reading-frames` is the one task whose point is a TOOL CHOICE rather than a",
     "value: the model must call the translator in all-frames mode with an ORF floor,",
@@ -164,6 +165,115 @@
         }
       ]
     },
+    {
+      "id": "protein-charge",
+      "category": "protein",
+      "tier": "full",
+      "covers": [
+        "molbio_protein_charge"
+      ],
+      "instruction": "I need to know how this peptide's charge changes with pH. Plot the net charge from pH 0 to 14, report the isoelectric point and the net charge at pH 7.4, and tell me which pK set the numbers come from. Write the figure to charge.svg.\n\nMKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQ",
+      "timeout_ms": 240000,
+      "expect_tools": [
+        "molbio_protein_charge"
+      ],
+      "assertions": [
+        {
+          "where": "tool",
+          "pattern": "33 aa · Bjellqvist 1993 pK set · pI 10\\.63 · charge at pH 7\\.4 2\\.9835 e \\(net positive\\)"
+        },
+        {
+          "where": "tool",
+          "pattern": "Curve over pH 0-14 \\(29 points; range -4\\.9682 \\.\\. 7\\.9996 e\\)"
+        },
+        {
+          "where": "answer",
+          "pattern": "10\\.6"
+        },
+        {
+          "where": "answer",
+          "pattern": "2\\.98|3\\.0|net positive"
+        },
+        {
+          "where": "answer",
+          "pattern": "Bjellqvist|pK"
+        }
+      ]
+    },
+    {
+      "id": "dotplot",
+      "category": "bench-analysis",
+      "tier": "full",
+      "covers": [
+        "molbio_dotplot"
+      ],
+      "instruction": "I want to see the repeat structure of this 46 bp sequence. Draw a self dotplot with a 5-mer word, covering both direct and inverted repeats, and tell me how many direct and how many inverted matches it finds. Write the figure to dot.svg.\n\nTTAGGCACGTAGCTAGGCTAACGTTAGGCACGTAGCTAGGCTAACG",
+      "timeout_ms": 240000,
+      "expect_tools": [
+        "molbio_dotplot"
+      ],
+      "assertions": [
+        {
+          "where": "tool",
+          "pattern": "46 bp · word 5 · 88 direct / 18 inverted match\\(es\\); 88 \\+ 18 occupied cell\\(s\\)"
+        },
+        {
+          "where": "tool",
+          "pattern": "Exact k-mer view \\(black = direct, red = inverted\\)"
+        },
+        {
+          "where": "answer",
+          "pattern": "88"
+        },
+        {
+          "where": "answer",
+          "pattern": "18"
+        },
+        {
+          "where": "answer",
+          "pattern": "direct|inverted|repeat"
+        }
+      ]
+    },
+    {
+      "id": "contamination-screen",
+      "category": "bench-analysis",
+      "tier": "full",
+      "covers": [
+        "molbio_contamination_screen"
+      ],
+      "instruction": "I have this 122 bp sequence from a miniprep and I am worried it is contaminated with vector backbone or Illumina/Nextera adapter. Screen it against common vector and adapter signatures, tell me which signatures hit and their positions, and say whether this is proof of contamination.\n\n{seq:contamination}",
+      "timeout_ms": 240000,
+      "expect_tools": [
+        "molbio_contamination_screen"
+      ],
+      "assertions": [
+        {
+          "where": "tool",
+          "pattern": "sequence input: 1 of 1 entry, 122 bp; 2 signature\\(s\\) hit, 1 entry with a hit\\."
+        },
+        {
+          "where": "tool",
+          "pattern": "Illumina Universal \\[adapter/adapter\\] 1/1 \\(100%\\), best 0 mismatch\\(es\\); e\\.g\\. input 111-122 \\(\\+\\)"
+        },
+        {
+          "where": "tool",
+          "pattern": "pUC/pBR322 origin \\[vector/origin\\] 1/1 \\(100%\\), best 0 mismatch\\(es\\); e\\.g\\. input 1-30 \\(\\+\\)"
+        },
+        {
+          "where": "answer",
+          "pattern": "pUC|pBR322|vector"
+        },
+        {
+          "where": "answer",
+          "pattern": "Illumina|adapter"
+        },
+        {
+          "where": "answer",
+          "pattern": "not proof|short signature|does not prove|suggest|consistent"
+        }
+      ]
+    },
     {
       "id": "codon-optimize",
       "category": "bench-analysis",

package/benchmark/tasks/09-formats.json

@@ -1,6 +1,10 @@
 {
   "$comment": [
-    "Codon usage, phylogeny, and the two file-parsing tools.",
+    "Codon usage, phylogeny, FASTQ trimming, and the two file-parsing tools.",
+    "",
+    "`fastq-trim` belongs here rather than under visualisation: it reads a FASTQ,",
+    "transforms every record, and writes a FASTQ/FASTA back. The task pins the",
+    "before/after counts and the per-stage trim reasons, not just 'it ran'.",
     "",
     "The parsing tools appear here as a CHAIN rather than alone: a model that",
     "answers a question about a GenBank record without parsing it is doing",
@@ -128,6 +132,45 @@
         }
       ]
     },
+    {
+      "id": "fastq-trim",
+      "category": "sequence-io",
+      "tier": "full",
+      "covers": [
+        "molbio_fastq_trim"
+      ],
+      "instruction": "These four reads are from an old Illumina run: r1 has a low-quality 3' tail, r2 carries the Illumina Universal adapter, r3 has a poly-G tail, and r4 is very short. Trim the low-quality tail with a 3-base window at mean Q30, remove the adapter and everything after it, trim poly-G runs of 8 or more, drop reads shorter than 20 bp, and write the survivors to trimmed.fq. Tell me how many reads and bases went in and out, how many were trimmed or dropped, and why.\n",
+      "timeout_ms": 240000,
+      "expect_tools": [
+        "molbio_fastq_trim"
+      ],
+      "assertions": [
+        {
+          "where": "tool",
+          "pattern": "FASTQ trim: 4 of 4 read\\(s\\) scanned \\(127 bases\\) -> 3 read\\(s\\) \\(80 bases\\); 3 trimmed, 1 dropped\\."
+        },
+        {
+          "where": "tool",
+          "pattern": "quality 1 · adapter 1 · poly-G 1 · poly-A 0 · primer 0; dropped by length 1, by N 0"
+        },
+        {
+          "where": "tool",
+          "pattern": "Saved FASTQ to .*trimmed\\.fq\\."
+        },
+        {
+          "where": "answer",
+          "pattern": "3 .{0,20}(read|kept|surviv)|(kept|surviv).{0,20}3"
+        },
+        {
+          "where": "answer",
+          "pattern": "80"
+        },
+        {
+          "where": "answer",
+          "pattern": "adapter|poly-G|quality|drop"
+        }
+      ]
+    },
     {
       "id": "batch-analysis",
       "category": "formats",

package/benchmark/verifications.mjs

@@ -74,6 +74,7 @@ const FILE_SETUPS = {
   'chart-volcano': { 'de.csv': FIXTURES.DE_CSV },
   'chart-heatmap': { 'expression.tsv': FIXTURES.HEATMAP_TSV },
   'batch-analysis': { 'pUC118.gb': GENBANK_TEXT },
+  'fastq-trim': { 'reads.fq': FIXTURES.TRIM_FASTQ_TEXT },
 };
 
 /**
@@ -252,6 +253,18 @@ export function invocationsFor(task) {
     'peptide-digest': () => [{ tool: 'molbio_peptide_digest', args: { sequence: FIXTURES.DIGEST_PEPTIDE, enzyme: 'trypsin', missed: 0 } }],
     'helical-wheel': () => [{ tool: 'molbio_helical_wheel', args: { sequence: FIXTURES.AMPHIPATHIC_PEPTIDE, title: 'amphipathic test' } }],
     hydropathy: () => [{ tool: 'molbio_hydropathy_plot', args: { sequence: FIXTURES.DIGEST_PEPTIDE } }],
+    'protein-charge': () => [
+      { tool: 'molbio_protein_charge', args: { sequence: FIXTURES.DIGEST_PEPTIDE, output_path: at('charge.svg') } },
+    ],
+    dotplot: () => [
+      { tool: 'molbio_dotplot', args: { sequence: FIXTURES.DOTPLOT_SEQUENCE, word: 5, output_path: at('dot.svg') } },
+    ],
+    'contamination-screen': () => [
+      { tool: 'molbio_contamination_screen', args: { sequence: FIXTURES.CONTAMINATION_SEQUENCE } },
+    ],
+    'fastq-trim': () => [
+      { tool: 'molbio_fastq_trim', args: { path: at('reads.fq'), output_path: at('trimmed.fq'), min_quality: 30, quality_window: 3, poly_g: true, adapter: 'AGATCGGAAGAG', min_length: 20 } },
+    ],
 
     // bench analysis
     'codon-optimize': () => [{ tool: 'molbio_codon_optimize', args: { sequence: FIXTURES.CDS, host: 'e_coli' } }],

package/build/client-bundle.mjs

@@ -40,7 +40,7 @@ const checkOnly = process.argv.slice(2).includes('--check');
 /**
  * The bundles to emit. The SAME browser half ships through two channels:
  *
- * - `dsh-molbio-tools` — the plugin package: one install gives the 57 tools
+ * - `dsh-molbio-tools` — the plugin package: one install gives the 64 tools
  *   plus the panel (its host half also registers the tools).
  * - `dsh-molbio-panel` — a panel-only package: installing it adds the tab to a
  *   profile WITHOUT dragging the tools into every session of that profile,

package/build/client-entry.mjs

@@ -36,6 +36,8 @@ import {
   childPath,
   classifyEntry,
   credentialInfo,
+  figureCardSummary,
+  figureCardView,
   isMolbioDetailSubject,
   remoteFailure,
   decodeWorkspaceBytes,
@@ -294,8 +296,10 @@ function papersTitle() {
   return 'Papers';
 }
 
-/** The tool names whose transcript card this package draws. */
+/** The tool names whose transcript card this package draws (plasmid maps). */
 const MAP_TOOL_KEYS = ['molbio_plasmid_map', 'molbio_plasmid_map_file'];
+/** Figure tools: a drawn logo / gRNA map plus (for gRNA) the ranked list. */
+const FIGURE_TOOL_KEYS = ['molbio_sequence_logo', 'molbio_grna_design'];
 
 /**
  * The transcript card for the map tools (`tool.call.toolview`, keyed by tool
@@ -364,6 +368,72 @@ function MolbioMapCard({ block, inspect }) {
   return h('div', { style: styles.card }, ...content);
 }
 
+/**
+ * The transcript card for the sequence-logo and gRNA tools. The logo card draws
+ * the logo; the gRNA card draws the map when `map_path` was requested AND lists
+ * the top-ranked guides (a gRNA call without a map still gets the table). Like
+ * the map card it is a pure function of the block, and everything it reads is
+ * validated and bounded by `figureCardView`.
+ */
+function MolbioFigureCard({ block, inspect }) {
+  const settled = block !== null && typeof block === 'object' && block.kind === 'tool-result';
+  const view = figureCardView(settled ? block.meta : undefined);
+  const host = useRef(null);
+  const svg = view.kind === 'figure' ? view.svg : '';
+  const [drawError, setDrawError] = useState(null);
+
+  useEffect(() => {
+    const node = host.current;
+    if (node === null) return;
+    node.replaceChildren();
+    if (svg === '') return;
+    const parsed = new DOMParser().parseFromString(svg, 'image/svg+xml');
+    if (parsed.querySelector('parsererror') !== null) {
+      setDrawError('the figure markup could not be parsed as SVG');
+      return;
+    }
+    setDrawError(null);
+    const element = parsed.documentElement;
+    element.setAttribute('style', 'width:100%;height:auto;max-width:640px');
+    node.append(document.importNode(element, true));
+  }, [svg]);
+
+  const content = [h('div', { key: 'head', style: styles.cardHead }, settled ? figureCardSummary(view) : 'Drawing the figure…')];
+  if (view.kind === 'figure') {
+    if (drawError !== null) content.push(h('div', { key: 'drawerr', style: styles.cardNote }, drawError));
+    content.push(h('div', { key: 'svg', ref: host, style: styles.cardSvg }));
+  } else {
+    content.push(h('div', { key: 'note', style: styles.cardNote }, view.message));
+  }
+  if (view.guides.length > 0) {
+    const head = ['#', 'Guide', 'PAM', 'Position', 'Score', 'Off-targets'];
+    const rows = view.guides.map((guide) => h('tr', { key: guide.rank },
+      h('td', { style: styles.td }, String(guide.rank)),
+      h('td', { style: styles.td }, guide.sequence),
+      h('td', { style: styles.td }, guide.pam === '' ? '—' : guide.pam),
+      h('td', { style: styles.td }, `${guide.strand === 'reverse' ? '−' : '+'}${guide.start}-${guide.end}`),
+      h('td', { style: styles.td }, String(guide.score)),
+      h('td', { style: styles.td }, String(guide.offTargets)),
+    ));
+    content.push(h('table', { key: 'guides', style: styles.table },
+      h('thead', null, h('tr', null, ...head.map((label) => h('th', { key: label, style: styles.th }, label)))),
+      h('tbody', null, ...rows)));
+  }
+  if (view.svgPath !== '') content.push(h('div', { key: 'path', style: styles.cardPath }, view.svgPath));
+  if (view.csvPath !== '') content.push(h('div', { key: 'csv', style: styles.cardPath }, view.csvPath));
+  if (settled && block.isError === true) {
+    const text = (Array.isArray(block.content) ? block.content : [])
+      .map((item) => (item !== null && typeof item === 'object' && item.type === 'text' ? String(item.text ?? '') : ''))
+      .join('\n')
+      .trim();
+    content.push(h('div', { key: 'err', style: styles.error }, text === '' ? 'The call failed.' : text));
+    if (typeof inspect === 'function') {
+      content.push(h('button', { key: 'inspect', style: styles.cardButton, onClick: () => inspect() }, 'Inspect'));
+    }
+  }
+  return h('div', { style: styles.card }, ...content);
+}
+
 /**
  * The literature panel: the workspace `papers.json` the molbio_paper_* tools
  * maintain, rendered as a searchable reading list with a detail pane.
@@ -712,6 +782,15 @@ function apply(ctx) {
       key: toolName,
     }, MolbioMapCard)), `molbio panel: ${toolName} card`);
   }
+  // Figure cards: the sequence-logo and gRNA tools declare a `molbio-figure`
+  // projection; the same component draws a logo or a gRNA map and, for gRNA,
+  // lists the top-ranked guides even when no map was requested.
+  for (const toolName of FIGURE_TOOL_KEYS) {
+    ctx.effect(() => ctx.slots.inject('tool.call.toolview', () => ctx.slots.register({
+      name: 'tool.call.toolview',
+      key: toolName,
+    }, MolbioFigureCard)), `molbio panel: ${toolName} card`);
+  }
   // Plugins -> the installed plugin's detail page: the one place a user can
   // store the NCBI key without editing a YAML file or exporting a variable.
   //

package/build/panel-core.mjs

@@ -268,6 +268,91 @@ export function mapCardSummary(view) {
   return parts.join(' · ');
 }
 
+// ── figure cards (the same `tool.call.toolview` seat) ───────────────────────
+
+/** The meta kind the sequence-logo and gRNA tools attach to their results. */
+export const FIGURE_CARD_KIND = 'molbio-figure';
+
+const CARD_SUMMARY_MAX = 300;
+const CARD_PATH_MAX = 500;
+const CARD_GUIDES_MAX = 5;
+
+/** A bounded string, or '' when the value is not a string. */
+function cardText(value, max) {
+  return typeof value === 'string' ? value.slice(0, max) : '';
+}
+
+/** One guide row, validated field by field; malformed rows are dropped. */
+function cardGuide(row) {
+  if (row === null || typeof row !== 'object' || Array.isArray(row)) return undefined;
+  const sequence = cardText(row.sequence, 60);
+  if (sequence === '') return undefined;
+  return {
+    rank: Number.isInteger(row.rank) ? row.rank : 0,
+    sequence,
+    pam: cardText(row.pam, 12),
+    strand: row.strand === 'reverse' ? 'reverse' : 'forward',
+    start: Number.isInteger(row.start) ? row.start : 0,
+    end: Number.isInteger(row.end) ? row.end : 0,
+    score: typeof row.score === 'number' && Number.isFinite(row.score) ? row.score : 0,
+    offTargets: Number.isInteger(row.off_target_count) ? row.off_target_count : 0,
+  };
+}
+
+/**
+ * Read a tool-result block's meta into what the figure card draws.
+ *
+ * Like `mapCardView`, the value is a projection this package produced itself,
+ * but the card renders inside the conversation, so every field is checked and
+ * bounded rather than trusted: a block from an older version, another tool, a
+ * running call or a failed run must degrade to a notice, never throw.
+ *
+ * @param {unknown} meta the block's meta, as the client received it.
+ * @returns {{kind: 'notice', message: string, ...} | {kind: 'figure', figure:
+ *   'logo'|'grna', summary: string, svg: string, svgPath: string,
+ *   csvPath: string, mapPath: string, guides: Array}}
+ */
+export function figureCardView(meta) {
+  if (meta === null || typeof meta !== 'object' || Array.isArray(meta)) {
+    return { kind: 'notice', message: 'No figure data was attached to this call.' };
+  }
+  if (meta.kind !== FIGURE_CARD_KIND) {
+    return { kind: 'notice', message: 'This call carries no figure.' };
+  }
+  const figure = meta.figure === 'grna' ? 'grna' : meta.figure === 'logo' ? 'logo' : '';
+  if (figure === '') {
+    return { kind: 'notice', message: 'This call carries an unknown figure type.' };
+  }
+  const base = {
+    figure,
+    summary: cardText(meta.summary, CARD_SUMMARY_MAX),
+    svgPath: cardText(meta.svg_path, CARD_PATH_MAX),
+    csvPath: cardText(meta.csv_path, CARD_PATH_MAX),
+    mapPath: cardText(meta.map_path, CARD_PATH_MAX),
+    guides: Array.isArray(meta.guides)
+      // Bound the work before validating, then keep at most five VALID rows:
+      // malformed entries must not consume the budget and hide good ones.
+      ? meta.guides.slice(0, 50).map(cardGuide).filter((guide) => guide !== undefined).slice(0, CARD_GUIDES_MAX)
+      : [],
+    svg: '',
+  };
+  if (!isSvgMarkup(meta.svg)) {
+    const message = meta.svg_missing === true
+      ? 'No picture was requested for this call; the numbers are in the tool result.'
+      : meta.svg_omitted === true
+        ? `The figure is too large to draw inline (${Math.round((Number.isInteger(meta.svg_bytes) ? meta.svg_bytes : 0) / 1024)} KB); the written file is named below.`
+        : 'The figure markup did not travel with this call.';
+    return { kind: 'notice', message, ...base };
+  }
+  return { kind: 'figure', ...base, svg: meta.svg };
+}
+
+/** The header line for a figure card, with a stable fallback. */
+export function figureCardSummary(view) {
+  if (view.summary !== '') return view.summary;
+  return view.figure === 'logo' ? 'Sequence logo' : 'gRNA design';
+}
+
 // ── literature library (papers.json) ────────────────────────────────────────
 
 /** The library file the molbio_paper_* tools write, relative to the workspace. */

package/build/preset-patch.mjs

@@ -101,7 +101,7 @@ const ANCHOR = [
   '#',
   '# Keep the tool in the PRESET and only the anchor here. An earlier version of',
   "# this file inserted a host row for the tool itself (`name: dsh-molbio-tools`),",
-  "# which both registered all 60 tools globally and collided with the preset's own",
+  "# which both registered every tool globally and collided with the preset's own",
   '# copy of that row:',
   '#',
   '#     broken: "tool-molbio (...): never started"',

package/build/release-preflight.mjs

@@ -41,7 +41,7 @@ import { gunzipSync } from 'node:zlib';
  * The two npm entries this repository publishes, in publish order.
  *
  * THEY DO NOT SHARE A VERSION LINE, and that is deliberate rather than an
- * oversight to be "fixed" here. The root package carries the 60 tools and moves
+ * oversight to be "fixed" here. The root package carries the 64 tools and moves
  * with every toolset release; `dsh-molbio-panel` carries only the browser panel
  * and moves when the panel's own artifact moves. The tag names the ROOT version
  * (`v0.19.0`), and each entry is checked against its own declared version —

package/charts.mjs

@@ -60,6 +60,25 @@ import {
   textRun,
 } from './svgio.mjs';
 
+// ── data-sized min/max ──────────────────────────────────────────────────────
+//
+// A table this module accepts can hold MAX_ROWS (200 000) values. Spreading an
+// array that large into Math.min/Math.max overflows the engine's argument limit
+// with a RangeError, so the data-sized extrema are computed with loops. Fixed-
+// size arrays (bins, colour stops, density grids) still use the spread form.
+
+function minData(values) {
+  let min = Infinity;
+  for (const value of values) if (value < min) min = value;
+  return min;
+}
+
+function maxData(values) {
+  let max = -Infinity;
+  for (const value of values) if (value > max) max = value;
+  return max;
+}
+
 // ── canvas ──────────────────────────────────────────────────────────────────
 
 export const CHART_WIDTH = 720;
@@ -130,8 +149,8 @@ export function histogramBins(values, requestedBins) {
   const finite = values.filter((value) => Number.isFinite(value));
   if (finite.length === 0) throw new MolbioInputError('a histogram needs at least one finite value');
   const n = finite.length;
-  const min = Math.min(...finite);
-  const max = Math.max(...finite);
+  const min = minData(finite);
+  const max = maxData(finite);
   let binCount;
   let rule;
   if (requestedBins !== undefined) {
@@ -634,9 +653,9 @@ export function renderBoxPlot({ title, x_label, y_label, series }) {
     const stats = boxStats(validateFinite(entry.values, `series ${index + 1} values`));
     return { label, stats, color: entry.color ?? SERIES_COLORS[index % SERIES_COLORS.length] };
   });
-  const lows = prepared.map((entry) => Math.min(entry.stats.whisker_low, ...entry.stats.outliers, entry.stats.min));
-  const highs = prepared.map((entry) => Math.max(entry.stats.whisker_high, ...entry.stats.outliers, entry.stats.max));
-  const [domainMin, domainMax] = padDomain(Math.min(...lows), Math.max(...highs));
+  const lows = prepared.map((entry) => Math.min(entry.stats.whisker_low, minData(entry.stats.outliers), entry.stats.min));
+  const highs = prepared.map((entry) => Math.max(entry.stats.whisker_high, maxData(entry.stats.outliers), entry.stats.max));
+  const [domainMin, domainMax] = padDomain(minData(lows), maxData(highs));
   const { parts, plot } = frame(title);
   const y = yAxis(parts, plot, domainMin, domainMax, y_label);
   const slot = plot.width / prepared.length;
@@ -695,8 +714,8 @@ export function renderLineChart({ title, x_label, y_label, series, markers = tru
   });
   const allX = prepared.flatMap((entry) => entry.xs);
   const allY = prepared.flatMap((entry) => entry.ys);
-  const [xMin, xMax] = padDomain(Math.min(...allX), Math.max(...allX));
-  const [yMin, yMax] = padDomain(Math.min(...allY), Math.max(...allY));
+  const [xMin, xMax] = padDomain(minData(allX), maxData(allX));
+  const [yMin, yMax] = padDomain(minData(allY), maxData(allY));
   const { parts, plot } = frame(title);
   const y = yAxis(parts, plot, yMin, yMax, y_label);
   const x = linearScale([xMin, xMax], [plot.x, plot.x + plot.width]);
@@ -719,11 +738,11 @@ export function renderLineChart({ title, x_label, y_label, series, markers = tru
   return {
     svg,
     stats: {
-      series: prepared.map((entry) => ({ label: entry.label, points: entry.xs.length, x_min: Math.min(...entry.xs), x_max: Math.max(...entry.xs), y_min: Math.min(...entry.ys), y_max: Math.max(...entry.ys) })),
+      series: prepared.map((entry) => ({ label: entry.label, points: entry.xs.length, x_min: minData(entry.xs), x_max: maxData(entry.xs), y_min: minData(entry.ys), y_max: maxData(entry.ys) })),
       series_count: prepared.length,
       point_count: prepared.reduce((sum, entry) => sum + entry.xs.length, 0),
-      x_range: [Math.min(...allX), Math.max(...allX)],
-      y_range: [Math.min(...allY), Math.max(...allY)],
+      x_range: [minData(allX), maxData(allX)],
+      y_range: [minData(allY), maxData(allY)],
     },
     marks: prepared.reduce((sum, entry) => sum + entry.xs.length, 0),
     plot,
@@ -815,7 +834,7 @@ export function renderViolinPlot({ title, x_label, y_label, series, bandwidth, s
   });
   const lows = prepared.map((entry) => entry.stats.min);
   const highs = prepared.map((entry) => entry.stats.max);
-  const [domainMin, domainMax] = padDomain(Math.min(...lows), Math.max(...highs));
+  const [domainMin, domainMax] = padDomain(minData(lows), maxData(highs));
   const { parts, plot } = frame(title);
   const y = yAxis(parts, plot, domainMin, domainMax, y_label);
   const slot = plot.width / prepared.length;
@@ -890,8 +909,8 @@ export function renderVolcanoPlot({ title, x_label, y_label, points, fold_change
   const significant = (point) => Math.abs(point.fold) >= fold_change_threshold && point.p <= p_threshold;
   const xs = prepared.map((point) => point.fold);
   const ys = prepared.map((point) => point.significance);
-  const [xMin, xMax] = padDomain(Math.min(0, ...xs), Math.max(0, ...xs));
-  const [yMin, yMax] = padDomain(0, Math.max(...ys, -Math.log10(p_threshold)));
+  const [xMin, xMax] = padDomain(Math.min(0, minData(xs)), Math.max(0, maxData(xs)));
+  const [yMin, yMax] = padDomain(0, Math.max(maxData(ys), -Math.log10(p_threshold)));
   const { parts, plot } = frame(title);
   const y = yAxis(parts, plot, yMin, yMax, y_label ?? '-log10 p');
   const x = linearScale([xMin, xMax], [plot.x, plot.x + plot.width]);
@@ -936,7 +955,7 @@ export function renderVolcanoPlot({ title, x_label, y_label, points, fold_change
       down_count: prepared.filter((point) => significant(point) && point.fold < 0).length,
       fold_change_threshold,
       p_threshold,
-      max_significance: Math.max(...ys),
+      max_significance: maxData(ys),
       labelled: [...labelled],
     },
     marks: prepared.length,
@@ -1000,8 +1019,8 @@ export function renderHeatmap({ title, x_label, y_label, rows, columns, matrix,
   }
   const flat = values.flat().filter((value) => value !== null);
   if (flat.length === 0) throw new MolbioInputError('the matrix has no finite values to draw');
-  const min = Math.min(...flat);
-  const max = Math.max(...flat);
+  const min = minData(flat);
+  const max = maxData(flat);
   const ramp = color_scale ?? (min < 0 ? 'divergingRedBlue' : 'viridis');
   if (COLOR_RAMPS[ramp] === undefined) {
     throw new MolbioInputError(`unknown color_scale ${JSON.stringify(color_scale)}; use ${Object.keys(COLOR_RAMPS).join(', ')}`);