@datagrok/proteomics 1.0.1 → 1.2.1

package/src/tests/enrichment-export.ts

@@ -0,0 +1,61 @@
+import * as DG from 'datagrok-api/dg';
+import {category, test, expect} from '@datagrok-libraries/test/src/test';
+import {SEMTYPE} from '../utils/proteomics-types';
+import {buildEnrichmentInputsCsv} from '../analysis/enrichment-export';
+
+/** DE'd DataFrame: G1 up, G2 down, G3 not significant (background only). */
+function makeDeDf(): DG.DataFrame {
+  const df = DG.DataFrame.fromColumns([
+    DG.Column.fromStrings('Gene names', ['G1', 'G2', 'G3']),
+    DG.Column.fromFloat32Array('log2FC', new Float32Array([2, -2, 0.1])),
+    DG.Column.fromFloat32Array('adj.p-value', new Float32Array([0.01, 0.01, 0.5])),
+  ]);
+  df.col('Gene names')!.semType = SEMTYPE.GENE_SYMBOL;
+  df.col('log2FC')!.semType = SEMTYPE.LOG2FC;
+  df.col('adj.p-value')!.semType = SEMTYPE.P_VALUE;
+  return df;
+}
+
+category('Enrichment Export', () => {
+  test('buildEnrichmentInputsCsv: up/down/background split matches thresholds', async () => {
+    const {csv, counts} = buildEnrichmentInputsCsv(makeDeDf(), 1.0, 0.05);
+    expect(counts.up, 1, 'one up gene');
+    expect(counts.down, 1, 'one down gene');
+    expect(counts.background, 3, 'all three genes in background');
+
+    const lines = csv.split('\n');
+    expect(lines[0], 'gene,list', 'tidy long header');
+    expect(lines.includes('G1,up'), true, 'G1 is up');
+    expect(lines.includes('G2,down'), true, 'G2 is down');
+    // Background is the full universe — every gene appears under background too.
+    expect(lines.includes('G1,background') && lines.includes('G2,background') &&
+      lines.includes('G3,background'), true, 'all genes listed as background');
+    // G3 is not significant → never up or down.
+    expect(lines.includes('G3,up') || lines.includes('G3,down'), false, 'G3 stays background-only');
+  });
+
+  test('buildEnrichmentInputsCsv: looser thresholds pull more genes in', async () => {
+    // p ≤ 0.6 and |fc| ≥ 0 promotes G3 (fc 0.1, p 0.5) to up.
+    const {counts} = buildEnrichmentInputsCsv(makeDeDf(), 0.0, 0.6);
+    expect(counts.up, 2, 'G1 and G3 now up');
+    expect(counts.down, 1, 'G2 still down');
+    expect(counts.background, 3, 'background unchanged');
+  });
+
+  test('buildEnrichmentInputsCsv: quotes a gene containing a comma', async () => {
+    const df = makeDeDf();
+    df.col('Gene names')!.set(0, 'G1,alias');
+    const {csv} = buildEnrichmentInputsCsv(df, 1.0, 0.05);
+    expect(csv.includes('"G1,alias",up'), true, 'comma-bearing field is CSV-quoted');
+  });
+
+  test('buildEnrichmentInputsCsv: throws without DE columns', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('Gene names', ['G1']),
+    ]);
+    df.col('Gene names')!.semType = SEMTYPE.GENE_SYMBOL;
+    let threw = false;
+    try { buildEnrichmentInputsCsv(df, 1.0, 0.05); } catch { threw = true; }
+    expect(threw, true, 'missing log2FC/adj.p-value is an error');
+  });
+});

package/src/tests/enrichment-visualization.ts

@@ -0,0 +1,340 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import * as rxjs from 'rxjs';
+import {category, test, expect} from '@datagrok-libraries/test/src/test';
+import {
+  CHART_TOP_MARKER_COL,
+  NEG_LOG10_FDR_COL,
+  openEnrichmentVisualization,
+  prepareEnrichmentChartColumns,
+  wireEnrichmentToVolcano,
+} from '../viewers/enrichment-viewers';
+import {SEMTYPE} from '../utils/proteomics-types';
+
+// --- Helpers ---
+
+/** Creates a mock enrichment DataFrame with the specified number of rows. */
+function makeMockEnrichmentDf(rowCount: number, longTermName?: string): DG.DataFrame {
+  const sources: string[] = [];
+  const termIds: string[] = [];
+  const termNames: string[] = [];
+  const pValues: number[] = [];
+  const fdrs: number[] = [];
+  const geneCounts: number[] = [];
+  const geneRatios: number[] = [];
+  const intersections: string[] = [];
+  const significants: boolean[] = [];
+
+  for (let i = 0; i < rowCount; i++) {
+    sources.push(i % 2 === 0 ? 'GO:BP' : 'KEGG');
+    termIds.push(`GO:${String(i).padStart(7, '0')}`);
+    termNames.push(longTermName && i === 0 ? longTermName : `Term ${i + 1}`);
+    const fdr = 0.001 * (i + 1);
+    pValues.push(fdr);
+    fdrs.push(fdr);
+    geneCounts.push(10 - Math.min(i, 9));
+    geneRatios.push(0.2 - i * 0.005);
+    intersections.push('TP53, BRCA1');
+    significants.push(fdr < 0.05);
+  }
+
+  const df = DG.DataFrame.fromColumns([
+    DG.Column.fromStrings('Source', sources),
+    DG.Column.fromStrings('Term ID', termIds),
+    DG.Column.fromStrings('Term Name', termNames),
+    DG.Column.fromFloat32Array('P-value', new Float32Array(pValues)),
+    DG.Column.fromFloat32Array('FDR', new Float32Array(fdrs)),
+    DG.Column.fromInt32Array('Gene Count', new Int32Array(geneCounts)),
+    DG.Column.fromFloat32Array('Gene Ratio', new Float32Array(geneRatios)),
+    DG.Column.fromStrings('Intersection', intersections),
+    DG.Column.fromList('bool', 'Significant', significants),
+  ]);
+  df.setTag('proteomics.enrichment', 'true');
+  return df;
+}
+
+/** Creates a mock protein DataFrame with gene symbols.
+ * Includes log2FC AND adj.p-value so createVolcanoPlot's column requirements
+ * (pickMetricColumn → adj.p-value) are satisfied. Tests B and C below construct
+ * a co-located volcano via openEnrichmentVisualization → createVolcanoPlot;
+ * without adj.p-value, the try/catch guard would swallow the dock and Tests B/C
+ * would falsely report missing layout instead of asserting layout presence. */
+function makeMockProteinDf(): DG.DataFrame {
+  const genes = ['TP53', 'BRCA1', 'EGFR', 'MYC', 'AKT1'];
+  const geneCol = DG.Column.fromStrings('Gene Name', genes);
+  geneCol.semType = SEMTYPE.GENE_SYMBOL;
+  const df = DG.DataFrame.fromColumns([
+    geneCol,
+    DG.Column.fromFloat32Array('log2FC', new Float32Array([1.5, -2.0, 0.5, 3.0, -1.0])),
+    // Bulk-init via fromFloat32Array — memory feedback_dg_column_bulk_init.
+    DG.Column.fromFloat32Array(
+      'adj.p-value', new Float32Array([0.001, 0.01, 0.5, 0.0001, 0.04])),
+  ]);
+  return df;
+}
+
+/** Adds a Direction column with the supplied Up/Down assignments. The
+ * directional-split branch of openEnrichmentVisualization keys on this. */
+function addDirectionColumn(df: DG.DataFrame, dirs: ('Up' | 'Down')[]): void {
+  df.columns.add(DG.Column.fromStrings('Direction', dirs as string[]));
+}
+
+/** Counts viewers on the supplied table view bound to `target` (same Dart-handle
+ * equality the platform uses). */
+function countViewersBoundTo(tv: DG.TableView, target: DG.DataFrame): number {
+  let n = 0;
+  for (const v of tv.viewers) {
+    if ((v.dataFrame as any)?.dart === (target as any).dart) n++;
+  }
+  return n;
+}
+
+/** Counts all viewers on the supplied table view. tv.viewers is Iterable, not
+ * an array, so we cannot read .length directly — iterate to count instead. */
+function countAllViewers(tv: DG.TableView): number {
+  let n = 0;
+  for (const _ of tv.viewers) n++;
+  return n;
+}
+
+/** Counts `true` cells in a boolean column without relying on stats semantics. */
+function trueCount(col: DG.Column): number {
+  let n = 0;
+  for (let i = 0; i < col.length; i++) {
+    if (col.get(i) === true) n++;
+  }
+  return n;
+}
+
+// --- Tests ---
+
+category('Enrichment Visualization', () => {
+  test('prepareEnrichmentChartColumns adds negLog10FDR on the same frame', async () => {
+    const df = makeMockEnrichmentDf(20);
+    prepareEnrichmentChartColumns(df, 15);
+    const negLogCol = df.col(NEG_LOG10_FDR_COL);
+    expect(negLogCol !== null, true);
+    // Row 0 FDR = 0.001, -log10(0.001) = 3.0
+    const val = negLogCol!.get(0) as number;
+    expect(Math.abs(val - 3.0) < 0.01, true);
+    // The charts bind to the passed frame — no cloned subset is produced.
+    expect(df.rowCount, 20);
+  });
+
+  test('prepareEnrichmentChartColumns marks exactly topN terms (no Direction)', async () => {
+    const df = makeMockEnrichmentDf(20);
+    prepareEnrichmentChartColumns(df, 15);
+    const marker = df.col(CHART_TOP_MARKER_COL)!;
+    expect(trueCount(marker), 15);
+  });
+
+  test('prepareEnrichmentChartColumns marks topN per direction', async () => {
+    const df = makeMockEnrichmentDf(20);
+    // First 10 rows Up, last 10 Down (rows are FDR-ascending by construction).
+    addDirectionColumn(df, Array.from({length: 20}, (_, i) => (i < 10 ? 'Up' : 'Down')));
+    prepareEnrichmentChartColumns(df, 5);
+    const marker = df.col(CHART_TOP_MARKER_COL)!;
+    // 5 Up + 5 Down = 10 marked terms.
+    expect(trueCount(marker), 10);
+  });
+
+  test('prepareEnrichmentChartColumns marks all when fewer rows than topN', async () => {
+    const df = makeMockEnrichmentDf(5);
+    prepareEnrichmentChartColumns(df, 15);
+    const marker = df.col(CHART_TOP_MARKER_COL)!;
+    expect(trueCount(marker), 5);
+  });
+
+  test('prepareEnrichmentChartColumns is idempotent on re-run', async () => {
+    const df = makeMockEnrichmentDf(20);
+    prepareEnrichmentChartColumns(df, 15);
+    const colsAfterFirst = df.columns.length;
+    prepareEnrichmentChartColumns(df, 15);
+    // Re-run replaces (ensureFreshFloat pattern) rather than duplicating.
+    expect(df.columns.length, colsAfterFirst);
+  });
+
+  test('wireEnrichmentToVolcano returns EMPTY without gene column', async () => {
+    const enrichDf = makeMockEnrichmentDf(3);
+    // Protein df without gene symbol semtype
+    const proteinDf = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('SomeColumn', ['A', 'B', 'C']),
+    ]);
+    const sub = wireEnrichmentToVolcano(enrichDf, proteinDf);
+    expect(sub === rxjs.Subscription.EMPTY, true);
+  });
+
+  test('wireEnrichmentToVolcano selects matching genes on protein DataFrame', async () => {
+    const enrichDf = makeMockEnrichmentDf(3);
+    // Set intersection to specific genes for first row
+    enrichDf.col('Intersection')!.set(0, 'TP53, BRCA1');
+    const proteinDf = makeMockProteinDf();
+
+    const sub = wireEnrichmentToVolcano(enrichDf, proteinDf);
+    expect(sub !== rxjs.Subscription.EMPTY, true);
+
+    // Trigger row change
+    enrichDf.currentRowIdx = 0;
+
+    // Check that TP53 (row 0) and BRCA1 (row 1) are selected
+    expect(proteinDf.selection.get(0), true);  // TP53
+    expect(proteinDf.selection.get(1), true);  // BRCA1
+    expect(proteinDf.selection.get(2), false); // EGFR
+    expect(proteinDf.selection.get(3), false); // MYC
+    expect(proteinDf.selection.get(4), false); // AKT1
+
+    sub.unsubscribe();
+  });
+
+  test('wireEnrichmentToVolcano clears selection before new selection', async () => {
+    const enrichDf = makeMockEnrichmentDf(3);
+    enrichDf.col('Intersection')!.set(0, 'TP53');
+    enrichDf.col('Intersection')!.set(1, 'EGFR');
+    const proteinDf = makeMockProteinDf();
+
+    // Pre-select row 4 (AKT1)
+    proteinDf.selection.set(4, true, false);
+    proteinDf.selection.fireChanged();
+
+    const sub = wireEnrichmentToVolcano(enrichDf, proteinDf);
+
+    // Select first enrichment row (TP53 only)
+    enrichDf.currentRowIdx = 0;
+
+    // AKT1 (row 4) should no longer be selected since selection was cleared
+    expect(proteinDf.selection.get(4), false);
+    // TP53 (row 0) should be selected
+    expect(proteinDf.selection.get(0), true);
+
+    sub.unsubscribe();
+  });
+
+  // Test B (light-touch declutter, 2026-06): the directional-split Up/Down
+  // dot+bar viewers now dock on the ENRICHMENT TableView, NOT the protein view —
+  // the user's volcano tab stays clean. This reverses the 13-09 co-dock-on-
+  // protein decision per the declutter request.
+  test('openEnrichmentVisualization docks dot/bar on enrichment view (directional)', async () => {
+    const enrichDf = makeMockEnrichmentDf(4);
+    addDirectionColumn(enrichDf, ['Up', 'Up', 'Down', 'Down']);
+    enrichDf.name = 'Enrichment (test B)';
+    const proteinDf = makeMockProteinDf();
+    proteinDf.name = 'Protein (test B)';
+
+    const proteinTv = grok.shell.addTableView(proteinDf);
+    const beforeViewerCount = countAllViewers(proteinTv);
+    const enrichTv = openEnrichmentVisualization(enrichDf, proteinDf);
+    try {
+      // The protein/volcano view must NOT gain the enrichment charts.
+      expect(countAllViewers(proteinTv), beforeViewerCount,
+        `protein view must not gain dot/bar viewers; gained ${countAllViewers(proteinTv) - beforeViewerCount}`);
+
+      // The 4 charts (Up dot + Up bar + Down dot + Down bar) live on the
+      // enrichment view alongside its grid (grid + 4 charts ⇒ ≥4).
+      expect(countAllViewers(enrichTv) >= 4, true,
+        `enrichment view should carry ≥4 dot/bar viewers; got ${countAllViewers(enrichTv)}`);
+
+      // No proteinDf-bound viewer should live on the enrichment view.
+      expect(countViewersBoundTo(enrichTv, proteinDf), 0,
+        'enrichment view must not carry a proteinDf-bound volcano');
+
+      // Data-layer cross-link still fires through the unchanged subscriptions.
+      enrichDf.currentRowIdx = 0;
+      expect(proteinDf.selection.trueCount >= 1, true,
+        'selecting an enrichment row should still highlight matching protein rows');
+    } finally {
+      enrichTv.close();
+      proteinTv.close();
+    }
+  });
+
+  // Test C (declutter): single-direction fallback path also docks on the enrichment view.
+  test('openEnrichmentVisualization docks dot/bar on enrichment view (single-direction)', async () => {
+    const enrichDf = makeMockEnrichmentDf(3);
+    // Intentionally NO Direction column — exercises the fallback branch.
+    enrichDf.name = 'Enrichment (test C)';
+    const proteinDf = makeMockProteinDf();
+    proteinDf.name = 'Protein (test C)';
+
+    const proteinTv = grok.shell.addTableView(proteinDf);
+    const beforeViewerCount = countAllViewers(proteinTv);
+    const enrichTv = openEnrichmentVisualization(enrichDf, proteinDf);
+    try {
+      // Protein/volcano view stays clean.
+      expect(countAllViewers(proteinTv), beforeViewerCount,
+        `protein view must not gain dot/bar viewers; gained ${countAllViewers(proteinTv) - beforeViewerCount}`);
+      // Single-direction fallback adds 2 charts (dot + bar) on the enrichment view.
+      expect(countAllViewers(enrichTv) >= 2, true,
+        `enrichment view should carry ≥2 dot/bar viewers; got ${countAllViewers(enrichTv)}`);
+
+      expect(countViewersBoundTo(enrichTv, proteinDf), 0,
+        'enrichment view must not carry a proteinDf-bound volcano');
+    } finally {
+      enrichTv.close();
+      proteinTv.close();
+    }
+  });
+
+  // Test D (declutter): focus now lands on the ENRICHMENT view (its dot/bar
+  // charts), leaving the volcano untouched on the protein tab.
+  test('openEnrichmentVisualization switches focus to enrichment TableView', async () => {
+    const enrichDf = makeMockEnrichmentDf(4);
+    addDirectionColumn(enrichDf, ['Up', 'Up', 'Down', 'Down']);
+    enrichDf.name = 'Enrichment (test D)';
+    const proteinDf = makeMockProteinDf();
+    proteinDf.name = 'Protein (test D)';
+
+    const proteinTv = grok.shell.addTableView(proteinDf);
+    const enrichTv = openEnrichmentVisualization(enrichDf, proteinDf);
+    try {
+      // Duck-type via Dart-handle identity — toJs returns fresh JS wrappers.
+      // grok.shell.v is a ViewBase (no dataFrame field on the base type), so
+      // cast to any before reaching for it.
+      const focusedDart = ((grok.shell.v as any)?.dataFrame as any)?.dart;
+      expect(focusedDart === (enrichDf as any).dart, true,
+        'focused view should be the enrichment TableView after enrichment runs');
+    } finally {
+      enrichTv.close();
+      proteinTv.close();
+    }
+  });
+
+  // --- Smart pathway filter banner (14-05 D-14) ---
+
+  test('enrichmentBannerRendersWhenTagSet', async () => {
+    const enrichDf = makeMockEnrichmentDf(3);
+    enrichDf.name = 'Enrichment (banner-on)';
+    enrichDf.setTag('proteomics.enrichment_smart_filtered', 'true');
+    enrichDf.setTag('proteomics.enrichment_smart_filtered_kept', '20');
+    enrichDf.setTag('proteomics.enrichment_smart_filtered_total', '47');
+    enrichDf.setTag('proteomics.enrichment_smart_filtered_dropped_parents', '3');
+    enrichDf.setTag('proteomics.enrichment_smart_filtered_cap', '15');
+    const proteinDf = makeMockProteinDf();
+    const tv = openEnrichmentVisualization(enrichDf, proteinDf);
+    try {
+      const banners = tv.root.querySelectorAll('[data-smart-filter-banner="true"]');
+      expect(banners.length >= 1, true, 'banner should be docked when tag is set');
+      const txt = (banners[0] as HTMLElement).textContent ?? '';
+      expect(txt.includes('Smart pathway filter active'), true);
+      expect(txt.includes('showing 20 of 47 terms'), true);
+      expect(txt.includes('dropped 3 generic parents'), true);
+      expect(txt.includes('capped at 15 per source'), true);
+      expect(txt.includes('Re-run with the filter off'), true);
+    } finally {
+      tv.close();
+    }
+  });
+
+  test('enrichmentBannerAbsentWhenTagUnset', async () => {
+    const enrichDf = makeMockEnrichmentDf(3);
+    enrichDf.name = 'Enrichment (banner-off)';
+    // No smart-filter tags set.
+    const proteinDf = makeMockProteinDf();
+    const tv = openEnrichmentVisualization(enrichDf, proteinDf);
+    try {
+      const banners = tv.root.querySelectorAll('[data-smart-filter-banner="true"]');
+      expect(banners.length, 0);
+    } finally {
+      tv.close();
+    }
+  });
+});

package/src/tests/enrichment.ts

@@ -0,0 +1,224 @@
+import * as DG from 'datagrok-api/dg';
+import {category, test, expect} from '@datagrok-libraries/test/src/test';
+import {buildEnrichmentDf, countSignificantProteins, splitGenesByDirection,
+  ORGANISM_LIST, GostResult} from '../analysis/enrichment';
+import {wireEnrichmentToVolcano} from '../viewers/enrichment-viewers';
+import {SEMTYPE} from '../utils/proteomics-types';
+
+// --- Helpers ---
+
+function makeMockResults(): GostResult[] {
+  return [
+    {
+      native: 'GO:0006915',
+      name: 'apoptotic process',
+      source: 'GO:BP',
+      p_value: 0.001,
+      significant: true,
+      term_size: 500,
+      query_size: 50,
+      intersection_size: 10,
+      effective_domain_size: 20000,
+      precision: 0.2,
+      recall: 0.02,
+      intersections: [['IEA'], ['IDA'], [], ['TAS']],
+    },
+    {
+      native: 'KEGG:04210',
+      name: 'Apoptosis',
+      source: 'KEGG',
+      p_value: 0.03,
+      significant: true,
+      term_size: 120,
+      query_size: 50,
+      intersection_size: 5,
+      effective_domain_size: 20000,
+      precision: 0.1,
+      recall: 0.042,
+      intersections: [[], ['evidence'], [], []],
+    },
+    {
+      native: 'REAC:R-HSA-109581',
+      name: 'Apoptosis',
+      source: 'REAC',
+      p_value: 0.12,
+      significant: false,
+      term_size: 80,
+      query_size: 50,
+      intersection_size: 3,
+      effective_domain_size: 20000,
+      precision: 0.06,
+      recall: 0.0375,
+      intersections: [['IEA'], [], [], []],
+    },
+  ];
+}
+
+// --- Tests ---
+
+category('Enrichment', () => {
+  test('buildEnrichmentDf creates correct schema', async () => {
+    const results = makeMockResults();
+    const queryGenes = ['TP53', 'BRCA1', 'EGFR', 'MYC'];
+    const df = buildEnrichmentDf(results, queryGenes);
+
+    // 7 data cols (Source/Term ID/Term Name/FDR/Gene Count/Gene Ratio/Intersection)
+    // + 1 Significant. g:GOSt with significance_threshold_method='fdr' returns the
+    // FDR-corrected p-value with no separate raw p-value, so the schema exposes
+    // only FDR — see buildEnrichmentDf in src/analysis/enrichment.ts.
+    expect(df.columns.length, 8);
+    expect(df.col('Source') !== null, true);
+    expect(df.col('Term ID') !== null, true);
+    expect(df.col('Term Name') !== null, true);
+    expect(df.col('FDR') !== null, true);
+    expect(df.col('Gene Count') !== null, true);
+    expect(df.col('Gene Ratio') !== null, true);
+    expect(df.col('Intersection') !== null, true);
+    expect(df.col('Significant') !== null, true);
+    expect(df.rowCount, 3);
+  });
+
+  test('buildEnrichmentDf sets enrichment tag', async () => {
+    const results = makeMockResults();
+    const df = buildEnrichmentDf(results, ['TP53', 'BRCA1', 'EGFR', 'MYC']);
+    expect(df.getTag('proteomics.enrichment'), 'true');
+  });
+
+  test('buildEnrichmentDf marks significant terms', async () => {
+    const results = makeMockResults(); // first two < 0.05, third > 0.05
+    const df = buildEnrichmentDf(results, ['TP53', 'BRCA1', 'EGFR', 'MYC']);
+    const sigCol = df.col('Significant')!;
+    expect(sigCol.get(0), true);  // p=0.001
+    expect(sigCol.get(1), true);  // p=0.03
+    expect(sigCol.get(2), false); // p=0.12
+  });
+
+  test('buildEnrichmentDf extracts intersection genes', async () => {
+    const queryGenes = ['TP53', 'BRCA1', 'EGFR', 'MYC'];
+    const results: GostResult[] = [{
+      native: 'GO:0006915',
+      name: 'apoptotic process',
+      source: 'GO:BP',
+      p_value: 0.01,
+      significant: true,
+      term_size: 500,
+      query_size: 4,
+      intersection_size: 2,
+      effective_domain_size: 20000,
+      precision: 0.5,
+      recall: 0.004,
+      intersections: [['IEA'], [], ['TAS'], []],
+    }];
+    const df = buildEnrichmentDf(results, queryGenes);
+    const intersectionVal = df.col('Intersection')!.get(0) as string;
+    expect(intersectionVal, 'TP53, EGFR');
+  });
+
+  test('countSignificantProteins counts correctly', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromFloat32Array('log2FC', new Float32Array([2.0, 0.5, -1.5, 3.0])),
+      DG.Column.fromFloat32Array('adjP', new Float32Array([0.01, 0.001, 0.1, 0.03])),
+    ]);
+    const result = countSignificantProteins(
+      df, 1.0, 0.05, df.col('log2FC')!, df.col('adjP')!,
+    );
+    // |2.0|>=1 && 0.01<=0.05 => yes; |0.5|<1 => no; |-1.5|>=1 && 0.1>0.05 => no; |3.0|>=1 && 0.03<=0.05 => yes
+    expect(result.significant, 2);
+    expect(result.total, 4);
+  });
+
+  test('countSignificantProteins handles null values', async () => {
+    const fcCol = DG.Column.fromFloat32Array('log2FC', new Float32Array([2.0, 0, -1.5]));
+    const pCol = DG.Column.fromFloat32Array('adjP', new Float32Array([0.01, 0, 0.03]));
+    // Set index 1 to null
+    fcCol.set(1, DG.FLOAT_NULL);
+    pCol.set(1, DG.FLOAT_NULL);
+
+    const df = DG.DataFrame.fromColumns([fcCol, pCol]);
+    const result = countSignificantProteins(df, 1.0, 0.05, fcCol, pCol);
+    // row 0: |2.0|>=1 && 0.01<=0.05 => yes; row 1: null => skip; row 2: |-1.5|>=1 && 0.03<=0.05 => yes
+    expect(result.significant, 2);
+    expect(result.total, 3); // all rows counted in total
+  });
+
+  // --- R2: directional split (13-02) ---
+
+  test('splitGenesByDirection splits significant genes by fc sign, shared background', async () => {
+    const geneForRow = new Map<number, string>([[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D']]);
+    const fc = new Float32Array([2.0, -2.0, 0.5, -3.0]);
+    const p = new Float32Array([0.01, 0.01, 0.001, 0.2]);
+    const {upGenes, downGenes, background} = splitGenesByDirection(geneForRow, fc, p, 1.0, 0.05);
+    // A: |2.0|>=1 & .01<=.05 → up. B: |-2.0|>=1 & .01<=.05 → down.
+    // C: |0.5|<1 → neither. D: .2>.05 → neither.
+    expect(upGenes.length, 1);
+    expect(upGenes[0], 'A');
+    expect(downGenes.length, 1);
+    expect(downGenes[0], 'B');
+    // Background = all detected genes (both directional queries share it).
+    expect(background.length, 4);
+    expect(background.includes('A') && background.includes('B') &&
+      background.includes('C') && background.includes('D'), true);
+    // Up/Down are disjoint.
+    expect(upGenes.some((g) => downGenes.includes(g)), false);
+  });
+
+  test('splitGenesByDirection skips null fc/p rows', async () => {
+    const geneForRow = new Map<number, string>([[0, 'A'], [1, 'B']]);
+    const fc = new Float32Array([2.0, 0]);
+    const p = new Float32Array([0.01, 0]);
+    fc[1] = DG.FLOAT_NULL;
+    p[1] = DG.FLOAT_NULL;
+    const {upGenes, downGenes, background} = splitGenesByDirection(geneForRow, fc, p, 1.0, 0.05);
+    expect(upGenes.length, 1);
+    expect(downGenes.length, 0);
+    expect(background.length, 2); // both rows still counted as detected background
+  });
+
+  test('buildEnrichmentDf adds Direction column when label given', async () => {
+    const df = buildEnrichmentDf(makeMockResults(), ['TP53', 'BRCA1', 'EGFR', 'MYC'], 0.05, 'Up');
+    const dir = df.col('Direction');
+    expect(dir !== null, true);
+    expect(dir!.get(0), 'Up');
+    expect(dir!.get(1), 'Up');
+    // Phase-9 schema preserved + Direction = 9 columns.
+    expect(df.columns.length, 9);
+    expect(df.col('Intersection') !== null, true);
+    expect(df.getTag('proteomics.enrichment'), 'true');
+  });
+
+  test('buildEnrichmentDf omits Direction column when no label', async () => {
+    const df = buildEnrichmentDf(makeMockResults(), ['TP53', 'BRCA1', 'EGFR', 'MYC']);
+    expect(df.col('Direction'), null);
+    expect(df.columns.length, 8);
+  });
+
+  test('wireEnrichmentToVolcano selects matching proteins, source DF unmutated', async () => {
+    const enrichDf = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('Intersection', ['TP53, EGFR']),
+      DG.Column.fromStrings('Direction', ['Up']),
+    ]);
+    const geneCol = DG.Column.fromStrings('Gene Symbol', ['TP53', 'EGFR', 'MYC']);
+    geneCol.semType = SEMTYPE.GENE_SYMBOL;
+    const proteinDf = DG.DataFrame.fromColumns([geneCol]);
+
+    const sub = wireEnrichmentToVolcano(enrichDf, proteinDf);
+    enrichDf.currentRowIdx = 0;
+    // TP53 + EGFR selected (from Intersection); MYC not.
+    expect(proteinDf.selection.trueCount, 2);
+    expect(proteinDf.selection.get(2), false);
+    // Cross-link must not mutate either source frame's shape.
+    expect(enrichDf.rowCount, 1);
+    expect(proteinDf.rowCount, 3);
+    sub.unsubscribe();
+  });
+
+  test('ORGANISM_LIST contains 9 entries with valid codes', async () => {
+    expect(ORGANISM_LIST.length, 9);
+    expect(ORGANISM_LIST[0].display, 'Homo sapiens (Human)');
+    expect(ORGANISM_LIST[0].code, 'hsapiens');
+    for (const org of ORGANISM_LIST) {
+      expect(org.display.length > 0, true);
+      expect(org.code.length > 0, true);
+    }
+  });
+});