@datagrok/proteomics 1.2.1 → 1.3.0

package/src/tests/publish-spike.ts

@@ -11,7 +11,7 @@ const SPIKE_TAG_KEYS = [
   'proteomics.published',
   'proteomics.published_at',
   'proteomics.published_by',
-  'proteomics.published_target',
+  'proteomics.published_project',
   'proteomics.published_de_method',
   'proteomics.published_fc_threshold',
   'proteomics.published_p_threshold',
@@ -78,7 +78,7 @@ function buildFixtureDataFrame(publishedId: string, nowIso: string): DG.DataFram
     'proteomics.published': 'true',
     'proteomics.published_at': nowIso,
     'proteomics.published_by': 'spike-operator',
-    'proteomics.published_target': 'SPIKE-TARGET-A',
+    'proteomics.published_project': 'SPIKE-PROJECT-A',
     'proteomics.published_de_method': 'limma',
     'proteomics.published_fc_threshold': '1.0',
     'proteomics.published_p_threshold': '0.05',

package/src/tests/rank-abundance.ts

@@ -0,0 +1,85 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import {category, test, expect} from '@datagrok-libraries/test/src/test';
+import {findAbundanceByCondition} from '../utils/abundance-detection';
+import {dockRankAbundanceCharts} from '../viewers/rank-abundance';
+import {setGroups} from '../analysis/experiment-setup';
+import {SEMTYPE} from '../utils/proteomics-types';
+
+/** Candidates-shaped mock: protein id + the two AVG Group Quantity columns +
+ * named groups (numerator / denominator). */
+function makeCandidatesDf(num: number[], den: number[], g1 = 'DMD', g2 = 'WT'): DG.DataFrame {
+  const prot = num.map((_, i) => `P${i + 1}`);
+  const df = DG.DataFrame.fromColumns([
+    DG.Column.fromStrings('ProteinGroups', prot),
+    DG.Column.fromFloat32Array('AVG Group Quantity Numerator', new Float32Array(num)),
+    DG.Column.fromFloat32Array('AVG Group Quantity Denominator', new Float32Array(den)),
+  ]);
+  df.col('ProteinGroups')!.semType = SEMTYPE.PROTEIN_ID;
+  setGroups(df, {group1: {name: g1, columns: []}, group2: {name: g2, columns: []}});
+  return df;
+}
+
+category('Rank-Abundance', () => {
+  test('resolver reads per-condition abundance from Candidates group quantities', async () => {
+    const df = makeCandidatesDf([100, 1000, 10], [50, 500, 5]);
+    const ab = findAbundanceByCondition(df);
+    expect(ab !== null, true);
+    expect(ab!.group1.name, 'DMD');
+    expect(ab!.group2.name, 'WT');
+    // log10(100) = 2, log10(1000) = 3
+    expect(Math.abs((ab!.group1.log10Intensity[0] as number) - 2) < 1e-4, true);
+    expect(Math.abs((ab!.group1.log10Intensity[1] as number) - 3) < 1e-4, true);
+    expect(Math.abs((ab!.group2.log10Intensity[0] as number) - Math.log10(50)) < 1e-4, true);
+  });
+
+  test('resolver returns null with no abundance columns and no group columns', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('ProteinGroups', ['P1', 'P2']),
+      DG.Column.fromFloat32Array('log2FC', new Float32Array([1.0, -1.0])),
+    ]);
+    expect(findAbundanceByCondition(df), null);
+  });
+
+  test('resolver maps non-positive abundance to null', async () => {
+    const df = makeCandidatesDf([100, 0, -5], [10, 10, 10]);
+    const ab = findAbundanceByCondition(df)!;
+    expect(ab.group1.log10Intensity[1], null); // 0 → null
+    expect(ab.group1.log10Intensity[2], null); // negative → null
+  });
+
+  test('dockRankAbundanceCharts adds rank column (1 = highest abundance) and docks', async () => {
+    const df = makeCandidatesDf([100, 1000, 10], [50, 500, 5]);
+    df.name = 'Rank-abundance test';
+    const tv = grok.shell.addTableView(df);
+    try {
+      const docked = dockRankAbundanceCharts(tv, df);
+      expect(docked, true);
+      const rankCol = df.col('rank: DMD');
+      expect(rankCol !== null, true);
+      // abundances [100,1000,10] → highest (1000) is rank 1, 100 → rank 2, 10 → rank 3
+      expect(rankCol!.get(1), 1);
+      expect(rankCol!.get(0), 2);
+      expect(rankCol!.get(2), 3);
+      // two rank-abundance scatter plots docked
+      let scatters = 0;
+      for (const v of tv.viewers) if (v.type === DG.VIEWER.SCATTER_PLOT) scatters++;
+      expect(scatters, 2);
+    } finally {
+      tv.close();
+    }
+  });
+
+  test('dockRankAbundanceCharts returns false when no abundance', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('ProteinGroups', ['P1', 'P2']),
+    ]);
+    df.name = 'No-abundance test';
+    const tv = grok.shell.addTableView(df);
+    try {
+      expect(dockRankAbundanceCharts(tv, df), false);
+    } finally {
+      tv.close();
+    }
+  });
+});

package/src/utils/abundance-detection.ts

@@ -0,0 +1,145 @@
+import * as DG from 'datagrok-api/dg';
+
+import {findColumn} from './column-detection';
+import {getGroups} from '../analysis/experiment-setup';
+
+/** Per-condition abundance, in log10(MS intensity) space, one value per protein
+ * row (null when the protein was not quantified in that condition). */
+export interface ConditionAbundance {
+  name: string;
+  log10Intensity: (number | null)[];
+}
+
+/** Abundance for the two experiment conditions — the input the rank-abundance
+ * (dynamic-range) plot ranks and plots. */
+export interface AbundanceByCondition {
+  group1: ConditionAbundance;
+  group2: ConditionAbundance;
+}
+
+/** Spectronaut Candidates carries pre-computed per-group mean abundance in these
+ * two columns (kept verbatim by the Candidates parser). group1 = Numerator. */
+const QTY_NUM_HINTS = ['avg group quantity numerator'];
+const QTY_DEN_HINTS = ['avg group quantity denominator'];
+
+/** Below this max value a column reads as log2-scale (log2 MS intensities rarely
+ * exceed ~40; linear intensities are >>1000). Mirrors the log2-status heuristic
+ * in `parsers/shared-utils`. */
+const LOG2_MAX_THRESHOLD = 45;
+
+/** log10 of a strictly-positive value, else null. */
+function log10OrNull(v: number): number | null {
+  return Number.isFinite(v) && v > 0 ? Math.log10(v) : null;
+}
+
+/** Single linear-abundance column → per-row log10. */
+function columnToLog10(col: DG.Column): (number | null)[] {
+  const out: (number | null)[] = new Array(col.length);
+  for (let i = 0; i < col.length; i++)
+    out[i] = col.isNone(i) ? null : log10OrNull(col.get(i) as number);
+  return out;
+}
+
+/** How a group's per-sample intensity columns are collapsed to one per-protein
+ * abundance on the Report path:
+ * - `arithmetic` — delinearize (2^v) log2 columns, average in linear space, then
+ *   log10. A true intensity mean; outlier-sensitive. Default (rank-abundance).
+ * - `geometric` — average in log space (mean of log10 values). log10 of the
+ *   geometric mean; the conventional summary for log-normal MS intensities and
+ *   the one the abundance-correlation viewer uses. */
+export type ReportMean = 'arithmetic' | 'geometric';
+
+/** Per-row abundance (log10 space) across a group's intensity columns, collapsed
+ * per `mode`. When the columns are log2-scale (Report analysis columns are
+ * log2-transformed) each value is treated accordingly so the axis is consistent
+ * with the Candidates path regardless of the source scale. */
+function groupMeanToLog10(
+  df: DG.DataFrame, colNames: string[], mode: ReportMean,
+): (number | null)[] {
+  const cols = colNames.map((n) => df.col(n)).filter((c): c is DG.Column => c != null);
+  const n = df.rowCount;
+  const out: (number | null)[] = new Array(n).fill(null);
+  if (cols.length === 0) return out;
+
+  // Detect log2 scale from the observed maximum across the group's columns.
+  let maxVal = -Infinity;
+  for (const c of cols) {
+    for (let i = 0; i < n; i++) {
+      if (!c.isNone(i)) {
+        const v = c.get(i) as number;
+        if (Number.isFinite(v) && v > maxVal) maxVal = v;
+      }
+    }
+  }
+  const isLog2 = Number.isFinite(maxVal) && maxVal < LOG2_MAX_THRESHOLD;
+  const LOG10_2 = Math.log10(2);
+
+  for (let i = 0; i < n; i++) {
+    let sum = 0; let count = 0;
+    for (const c of cols) {
+      if (c.isNone(i)) continue;
+      const v = c.get(i) as number;
+      if (!Number.isFinite(v)) continue;
+      if (mode === 'geometric') {
+        // Mean of log10 values = log10(geometric mean). A log2 column is already
+        // a log, so rebase (v * log10 2); a linear column is log10'd (skip <=0).
+        const lv = isLog2 ? v * LOG10_2 : log10OrNull(v);
+        if (lv == null) continue;
+        sum += lv;
+      } else {
+        // Arithmetic mean of linear intensities, log10'd after the loop.
+        sum += isLog2 ? Math.pow(2, v) : v;
+      }
+      count++;
+    }
+    if (count === 0) { out[i] = null; continue; }
+    out[i] = mode === 'geometric' ? sum / count : log10OrNull(sum / count);
+  }
+  return out;
+}
+
+/**
+ * Resolves per-condition abundance for the rank-abundance / dynamic-range plot,
+ * working on both pipeline shapes:
+ *
+ * - **Candidates** — the pre-computed `AVG Group Quantity Numerator/Denominator`
+ *   columns (linear); group1 = Numerator, group2 = Denominator. This is the
+ *   shape CK-omics builds this plot from.
+ * - **Report** — the per-group mean of each group's intensity columns (from the
+ *   `proteomics.groups` assignment), delinearized when log2-scale.
+ *
+ * Returns null when neither shape yields abundance (e.g. a Report with no group
+ * assignment yet, or an older Candidates export lacking group quantities) — the
+ * caller warns and no-ops.
+ *
+ * `opts.reportMean` selects how the Report path collapses each group's per-sample
+ * columns (default `arithmetic`, so rank-abundance is unchanged; the
+ * abundance-correlation viewer passes `geometric`). It does not affect the
+ * Candidates path, which reads the vendor's pre-computed per-group quantity.
+ */
+export function findAbundanceByCondition(
+  df: DG.DataFrame, opts?: {reportMean?: ReportMean},
+): AbundanceByCondition | null {
+  const groups = getGroups(df);
+  const mode: ReportMean = opts?.reportMean ?? 'arithmetic';
+
+  // Candidates path — precomputed per-group means.
+  const numCol = findColumn(df, '', QTY_NUM_HINTS);
+  const denCol = findColumn(df, '', QTY_DEN_HINTS);
+  if (numCol && denCol) {
+    return {
+      group1: {name: groups?.group1.name || 'Numerator', log10Intensity: columnToLog10(numCol)},
+      group2: {name: groups?.group2.name || 'Denominator', log10Intensity: columnToLog10(denCol)},
+    };
+  }
+
+  // Report path — per-group summary of each group's intensity columns.
+  if (groups && groups.group1.columns.length > 0 && groups.group2.columns.length > 0) {
+    return {
+      group1: {name: groups.group1.name || 'Group 1', log10Intensity: groupMeanToLog10(df, groups.group1.columns, mode)},
+      group2: {name: groups.group2.name || 'Group 2', log10Intensity: groupMeanToLog10(df, groups.group2.columns, mode)},
+    };
+  }
+
+  return null;
+}

package/src/viewers/abundance-correlation.ts

@@ -0,0 +1,208 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import {debounceTime} from 'rxjs/operators';
+
+import {findAbundanceByCondition} from '../utils/abundance-detection';
+import {findColumn} from '../utils/column-detection';
+import {ensureDirectionColumn} from './volcano';
+import {SEMTYPE, DEFAULT_FC_THRESHOLD, DEFAULT_P_THRESHOLD} from '../utils/proteomics-types';
+
+/**
+ * Abundance Correlation viewer — one dot per protein, its abundance in group 1
+ * (y) against group 2 (x), on geometric-mean log10 axes. Answers: how does each
+ * protein's abundance compare between the two conditions, and how tightly do the
+ * conditions track overall? Proteins on the y=x diagonal are unchanged; those off
+ * it are differentially abundant. Consolidates the former Group-Mean Correlation
+ * and Correlation Plot viewers.
+ *
+ * Works on both pipeline shapes via `findAbundanceByCondition`: a Spectronaut
+ * Candidates file (pre-computed AVG Group Quantity) or an annotated Report
+ * (per-sample intensities collapsed by geometric mean). Points are colored by the
+ * volcano's `direction` (reused when present so the two plots never disagree); the
+ * title carries Pearson r and Spearman rho recomputed live over the current
+ * filter. No regression line or fold-change guides — the y=x diagonal plus the
+ * `direction` color already carry effect size and the significance call.
+ */
+
+/** Hidden log10-abundance axis columns. Deliberately distinct from
+ * rank-abundance's `log10 intensity:` prefix — that viewer uses the arithmetic
+ * mean, this one the geometric, so they must not share a column and overwrite
+ * each other when both are opened on the same table. */
+const LOG10_PREFIX = 'log10 abundance: ';
+const DIAGONAL_COLOR = '#888888';
+
+/** Bulk-init a hidden float column, replacing any prior one so re-runs don't
+ * duplicate. */
+function ensureFreshHiddenFloat(df: DG.DataFrame, name: string, values: (number | null)[]): string {
+  if (df.columns.contains(name)) df.columns.remove(name);
+  const c = df.columns.addNewFloat(name);
+  c.init((i) => values[i]);
+  c.setTag('.hidden', 'true');
+  return name;
+}
+
+/** Pearson r over the pairwise-complete rows and the pair count. */
+export function pearson(x: (number | null)[], y: (number | null)[]): {r: number; n: number} {
+  let n = 0; let sx = 0; let sy = 0; let sxx = 0; let syy = 0; let sxy = 0;
+  for (let i = 0; i < x.length; i++) {
+    const a = x[i]; const b = y[i];
+    if (a == null || b == null || !Number.isFinite(a) || !Number.isFinite(b)) continue;
+    n++; sx += a; sy += b; sxx += a * a; syy += b * b; sxy += a * b;
+  }
+  if (n < 2) return {r: NaN, n};
+  const cov = sxy - (sx * sy) / n;
+  const vx = sxx - (sx * sx) / n;
+  const vy = syy - (sy * sy) / n;
+  const denom = Math.sqrt(vx * vy);
+  return {r: denom > 0 ? cov / denom : NaN, n};
+}
+
+/** Fractional ranks (1-based), ties averaged. Nulls keep their slot as null so
+ * the caller can drop the pair. */
+function fractionalRanks(v: (number | null)[]): (number | null)[] {
+  const idx = v.map((_, i) => i).filter((i) => v[i] != null && Number.isFinite(v[i] as number));
+  idx.sort((a, b) => (v[a] as number) - (v[b] as number));
+  const out: (number | null)[] = new Array(v.length).fill(null);
+  let i = 0;
+  while (i < idx.length) {
+    let j = i;
+    while (j + 1 < idx.length && (v[idx[j + 1]] as number) === (v[idx[i]] as number)) j++;
+    const avg = (i + j) / 2 + 1;
+    for (let k = i; k <= j; k++) out[idx[k]] = avg;
+    i = j + 1;
+  }
+  return out;
+}
+
+/** Spearman rho = Pearson over fractional ranks of the pairwise-complete rows. */
+export function spearman(x: (number | null)[], y: (number | null)[]): number {
+  return pearson(fractionalRanks(x), fractionalRanks(y)).r;
+}
+
+/** Reads two columns over the current filter into aligned (null-preserving) arrays. */
+function filteredPairs(df: DG.DataFrame, xName: string, yName: string): {xs: (number | null)[]; ys: (number | null)[]} {
+  const xc = df.col(xName); const yc = df.col(yName);
+  const xs: (number | null)[] = []; const ys: (number | null)[] = [];
+  if (!xc || !yc) return {xs, ys};
+  for (let i = 0; i < df.rowCount; i++) {
+    if (!df.filter.get(i)) continue;
+    xs.push(xc.isNone(i) ? null : (xc.get(i) as number));
+    ys.push(yc.isNone(i) ? null : (yc.get(i) as number));
+  }
+  return {xs, ys};
+}
+
+/** The on-canvas description (group comparison + correlation stats) over the
+ * current filter. Rendered via the scatterplot's `description` overlay — the
+ * `title` property is not painted in a docked viewer (the dock tab supplies the
+ * header), so the stats live here where they are actually visible. */
+export function correlationDescription(
+  g1Name: string, g2Name: string, df: DG.DataFrame, xName: string, yName: string,
+): string {
+  const {xs, ys} = filteredPairs(df, xName, yName);
+  const {r, n} = pearson(xs, ys);
+  const rho = spearman(xs, ys);
+  const rStr = Number.isFinite(r) ? r.toFixed(2) : 'NA';
+  const rhoStr = Number.isFinite(rho) ? rho.toFixed(2) : 'NA';
+  return `${g1Name} vs ${g2Name} — Pearson r = ${rStr} · Spearman ρ = ${rhoStr} · n = ${n}`;
+}
+
+/**
+ * Builds the abundance correlation scatter, or returns null when the frame
+ * carries no resolvable per-condition abundance (caller warns). Group naming
+ * follows the package (group1 = numerator = y).
+ */
+export function createAbundanceCorrelation(df: DG.DataFrame): DG.ScatterPlotViewer | null {
+  const ab = findAbundanceByCondition(df, {reportMean: 'geometric'});
+  if (!ab) return null;
+
+  const yName = ensureFreshHiddenFloat(df, LOG10_PREFIX + ab.group1.name, ab.group1.log10Intensity);
+  const xName = ensureFreshHiddenFloat(df, LOG10_PREFIX + ab.group2.name, ab.group2.log10Intensity);
+
+  // Reuse the volcano's existing coloring when present so the two plots agree;
+  // otherwise classify with the same thresholds. Best-effort — a frame without
+  // log2FC (e.g. abundance-only) simply renders uncolored.
+  let colorCol: string | undefined;
+  try {
+    colorCol = df.col('direction') ? 'direction'
+      : ensureDirectionColumn(df, DEFAULT_FC_THRESHOLD, DEFAULT_P_THRESHOLD);
+  } catch { colorCol = undefined; }
+
+  // y = x reference diagonal — replace any prior one so re-runs don't stack.
+  const diagFormula = `\${${yName}} = \${${xName}}`;
+  const fl: any = (df as any).meta?.formulaLines;
+  if (fl) {
+    try {
+      const items: any[] = Array.isArray(fl.items) ? fl.items : [];
+      fl.items = items.filter((l) => !(typeof l?.formula === 'string' &&
+        l.formula.includes(`\${${xName}}`) && l.formula.includes(`\${${yName}}`)));
+      fl.addLine({formula: diagFormula, color: DIAGONAL_COLOR, width: 1, visible: true});
+      // addLine defaults an empty title back to the formula, so blank it afterward
+      // to suppress the raw `${y} = ${x}` label Datagrok otherwise prints along the line.
+      const cur: any[] = Array.isArray(fl.items) ? fl.items : [];
+      const added = cur.find((l) => l?.formula === diagFormula);
+      if (added) { added.title = ''; fl.items = cur; }
+    } catch { /* best effort */ }
+  }
+
+  const sp = DG.Viewer.scatterPlot(df, {
+    x: xName,
+    y: yName,
+    ...(colorCol ? {color: colorCol} : {}),
+    showRegressionLine: false,
+    showViewerFormulaLines: true,
+    showFilteredOutPoints: true,
+    markerType: 'circle',
+    markerDefaultSize: 5,
+    title: 'Abundance Correlation',
+    // Stats go in the always-on description overlay (the title isn't painted).
+    description: correlationDescription(ab.group1.name, ab.group2.name, df, xName, yName),
+    descriptionVisibilityMode: 'Always',
+  } as any);
+
+  // Label with Display Name, gene fallback (matches Group-Mean / Plan 02).
+  const labelCol = findColumn(df, SEMTYPE.DISPLAY_NAME, ['display name']) ??
+    findColumn(df, SEMTYPE.GENE_SYMBOL, ['gene name', 'gene symbol']);
+  if (labelCol) {
+    sp.props.labelColumnNames = [labelCol.name];
+    sp.props.showLabelsFor = 'MouseOverRow';
+  }
+
+  // Filter-live stats: recompute r/rho on filter changes; tear the subscription
+  // down when this viewer closes so it doesn't leak or write to a dead viewer.
+  const sub = df.onFilterChanged.pipe(debounceTime(100)).subscribe(() => {
+    try {
+      sp.setOptions({description: correlationDescription(ab.group1.name, ab.group2.name, df, xName, yName)});
+    } catch { /* viewer closed */ }
+  });
+  const closeSub = grok.events.onViewerClosed.subscribe((args) => {
+    const v: any = (args as any)?.args?.viewer;
+    if (v && (v as any).dart === (sp as any).dart) {
+      sub.unsubscribe();
+      closeSub.unsubscribe();
+    }
+  });
+
+  return sp;
+}
+
+/**
+ * Menu entry point: docks the abundance correlation plot on the active protein
+ * view, or warns when there is no per-condition abundance.
+ */
+export function openAbundanceCorrelation(df: DG.DataFrame): void {
+  const view = grok.shell.tv;
+  if (!view || (view.dataFrame as any)?.dart !== (df as any).dart) {
+    grok.shell.warning('Open the protein table first, then run Abundance Correlation.');
+    return;
+  }
+  const sp = createAbundanceCorrelation(df);
+  if (!sp) {
+    grok.shell.warning(
+      'No per-condition abundance found. Abundance Correlation needs the Spectronaut ' +
+      'Candidates "AVG Group Quantity" columns, or an annotated Report (Annotate ' +
+      'Experiment) with per-sample intensities.');
+    return;
+  }
+  view.dockManager.dock(sp, DG.DOCK_TYPE.RIGHT, null, 'Abundance Correlation', 0.5);
+}

package/src/viewers/enrichment-viewers.ts

@@ -116,9 +116,25 @@ export function createEnrichmentBarChart(enrichDf: DG.DataFrame, direction?: 'Up
 }
 
 /**
- * Wires enrichment row changes to protein DataFrame selection.
- * When a row is selected in the enrichment table, matching protein rows
- * (by gene symbol from the Intersection column) are highlighted.
+ * Wires enrichment term interactions to the protein DataFrame, keyed on each
+ * term's comma-separated `Intersection` member genes → protein rows. All three
+ * enrichment charts (grid, dot plot, bar chart) share `enrichDf`, so this single
+ * full-frame wiring covers interactions in any of them.
+ *
+ * Everything drives the volcano's `selection` — the only channel the scatterplot
+ * paints visibly for a *set* of proteins (verified live: programmatic
+ * `rows.highlight` / `mouseOverRowFunc` do not render). Two channels feed that
+ * one selection, with the multi-term selection winning:
+ *  - (1)+(3) enrichment **selection** (dot-plot rubber-band, shift/ctrl-click
+ *    bars, ctrl-click grid rows) → the UNION of member proteins across every
+ *    selected term. An empty enrichment selection clears the volcano selection.
+ *  - (2) enrichment **current row** (a single clicked term) → that term's member
+ *    proteins, but ONLY when no terms are selected. While a multi-term selection
+ *    is active it governs, and current-row changes are ignored — so a trailing
+ *    current-row event (fired alongside a select gesture) can't clobber the union.
+ *
+ * The enrichment **filter** is intentionally NOT reflected (4) — filtering terms
+ * declutters the enrichment view; it must not repaint the volcano.
  */
 export function wireEnrichmentToVolcano(
   enrichDf: DG.DataFrame,
@@ -127,7 +143,7 @@ export function wireEnrichmentToVolcano(
   const geneCol = findColumn(proteinDf, SEMTYPE.GENE_SYMBOL, ['gene name', 'gene symbol']);
   if (!geneCol) return rxjs.Subscription.EMPTY;
 
-  // Build gene-to-row index
+  // Build gene -> protein-row index once.
   const geneToRows = new Map<string, number[]>();
   for (let i = 0; i < proteinDf.rowCount; i++) {
     if (!geneCol.isNone(i)) {
@@ -137,31 +153,49 @@ export function wireEnrichmentToVolcano(
     }
   }
 
-  return enrichDf.onCurrentRowChanged.subscribe(() => {
-    const rowIdx = enrichDf.currentRowIdx;
-    if (rowIdx < 0) return;
-
+  // Union of protein rows whose gene is a member of ANY of the given enrichment
+  // term rows (via each term's comma-separated Intersection string).
+  const proteinRowsForTerms = (termRows: Int32Array | number[]): Set<number> => {
+    const out = new Set<number>();
     const intersectionCol = enrichDf.col('Intersection');
-    if (!intersectionCol) return;
+    if (!intersectionCol) return out;
+    for (const r of termRows) {
+      if (r < 0 || intersectionCol.isNone(r)) continue;
+      const memberGenesStr = intersectionCol.get(r) as string;
+      if (!memberGenesStr) continue;
+      for (const gene of memberGenesStr.split(',').map((g) => g.trim()).filter(Boolean)) {
+        const rows = geneToRows.get(gene);
+        if (rows) for (const row of rows) out.add(row);
+      }
+    }
+    return out;
+  };
 
-    const memberGenesStr = intersectionCol.get(rowIdx) as string;
-    if (!memberGenesStr) return;
+  // Replace the volcano selection with exactly `rows` (empty set → cleared).
+  const selectProteins = (rows: Set<number>): void => {
+    proteinDf.selection.setAll(false, false);
+    for (const row of rows) proteinDf.selection.set(row, true, false);
+    proteinDf.selection.fireChanged();
+  };
 
-    const memberGenes = memberGenesStr.split(',').map((g) => g.trim()).filter(Boolean);
+  // (1)+(3) Selected terms → union of member proteins; no selection → cleared.
+  const applySelection = (): void => {
+    const termRows = enrichDf.selection.getSelectedIndexes();
+    selectProteins(termRows.length > 0 ? proteinRowsForTerms(termRows) : new Set());
+  };
 
-    // Clear previous selection
-    proteinDf.selection.setAll(false, false);
+  // (2) Single current term → that term's member proteins, but only while no
+  // terms are selected; an active multi-term selection governs and wins.
+  const applyCurrentRow = (): void => {
+    if (enrichDf.selection.trueCount > 0) return;
+    const idx = enrichDf.currentRowIdx;
+    selectProteins(idx >= 0 ? proteinRowsForTerms([idx]) : new Set());
+  };
 
-    // Set selection for matching genes
-    for (const gene of memberGenes) {
-      const rows = geneToRows.get(gene);
-      if (rows) {
-        for (const row of rows)
-          proteinDf.selection.set(row, true, false);
-      }
-    }
-    proteinDf.selection.fireChanged();
-  });
+  const sub = new rxjs.Subscription();
+  sub.add(enrichDf.onSelectionChanged.subscribe(() => applySelection()));
+  sub.add(enrichDf.onCurrentRowChanged.subscribe(() => applyCurrentRow()));
+  return sub;
 }
 
 /** True when `enrichDf` carries a Direction column with at least one row in