@datagrok/proteomics 1.0.0 → 1.2.0

package/src/tests/generic-parser.ts

@@ -0,0 +1,152 @@
+import * as DG from 'datagrok-api/dg';
+import {category, test, expect} from '@datagrok-libraries/test/src/test';
+import {SEMTYPE} from '../utils/proteomics-types';
+import {
+  detectDelimiter,
+  autoSuggestProteinIdColumn,
+  autoSuggestIntensityColumns,
+  detectLog2Status,
+  log2TransformColumns,
+  copyAsLog2Columns,
+  addPrimaryColumnIfNeeded,
+} from '../parsers/shared-utils';
+
+/** Builds a CSV or TSV string for testing. */
+function makeGenericCsv(params: {headers: string[]; rows: string[][]; delimiter?: string}): string {
+  const d = params.delimiter ?? ',';
+  return [params.headers.join(d), ...params.rows.map((r) => r.join(d))].join('\n');
+}
+
+category('Generic Parser', () => {
+  test('Generic: parses CSV with comma delimiter', async () => {
+    const text = makeGenericCsv({
+      headers: ['Protein', 'Intensity A', 'Intensity B', 'Intensity C'],
+      rows: [
+        ['P12345', '1000', '2000', '3000'],
+        ['P67890', '4000', '5000', '6000'],
+      ],
+    });
+    const delimiter = detectDelimiter(text);
+    expect(delimiter, ',');
+    const df = DG.DataFrame.fromCsv(text, {delimiter: ','});
+    expect(df.columns.length, 4);
+    expect(df.rowCount, 2);
+  });
+
+  test('Generic: parses TSV with tab delimiter', async () => {
+    const text = makeGenericCsv({
+      headers: ['Protein', 'Intensity A', 'Intensity B', 'Intensity C'],
+      rows: [
+        ['P12345', '1000', '2000', '3000'],
+        ['P67890', '4000', '5000', '6000'],
+      ],
+      delimiter: '\t',
+    });
+    const delimiter = detectDelimiter(text);
+    expect(delimiter, '\t');
+    const df = DG.DataFrame.fromCsv(text, {delimiter: '\t'});
+    expect(df.columns.length, 4);
+    expect(df.rowCount, 2);
+  });
+
+  test('Generic: auto-suggests protein ID column', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('Protein IDs', ['P12345']),
+      DG.Column.fromStrings('Gene names', ['BRCA1']),
+      DG.Column.fromList(DG.COLUMN_TYPE.FLOAT, 'Intensity A', [1000]),
+    ]);
+    const suggested = autoSuggestProteinIdColumn(df);
+    expect(suggested !== null, true);
+    expect(suggested!.name, 'Protein IDs');
+  });
+
+  test('Generic: auto-suggests intensity columns', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('id', ['P12345']),
+      DG.Column.fromList(DG.COLUMN_TYPE.FLOAT, 'Intensity Sample1', [1000]),
+      DG.Column.fromList(DG.COLUMN_TYPE.FLOAT, 'LFQ Sample2', [2000]),
+      DG.Column.fromStrings('notes', ['some note']),
+    ]);
+    const suggested = autoSuggestIntensityColumns(df);
+    expect(suggested.length, 2);
+    expect(suggested.includes('Intensity Sample1'), true);
+    expect(suggested.includes('LFQ Sample2'), true);
+  });
+
+  test('Generic: detects raw intensities for log2 toggle', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromList(DG.COLUMN_TYPE.FLOAT, 'vals', [50000, 100000, 200000]),
+    ]);
+    const result = detectLog2Status(df, ['vals']);
+    expect(result.isLog2, false);
+  });
+
+  test('Generic: detects already-log2 data', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromList(DG.COLUMN_TYPE.FLOAT, 'vals', [15.2, 18.7, 12.1]),
+    ]);
+    const result = detectLog2Status(df, ['vals']);
+    expect(result.isLog2, true);
+  });
+
+  test('Generic: log2TransformColumns produces correct values', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromList(DG.COLUMN_TYPE.FLOAT, 'Intensity A', [1024, 0, 2048]),
+    ]);
+    log2TransformColumns(df, ['Intensity A']);
+    const log2Col = df.col('log2(Intensity A)');
+    expect(log2Col !== null, true);
+    if (log2Col) {
+      expect(Math.abs(log2Col.get(0)! - 10.0) < 0.001, true);
+      expect(log2Col.isNone(1), true); // zero input -> FLOAT_NULL
+      expect(Math.abs(log2Col.get(2)! - 11.0) < 0.001, true);
+      expect(log2Col.semType, SEMTYPE.INTENSITY);
+    }
+    const origCol = df.col('Intensity A');
+    expect(origCol!.semType, SEMTYPE.INTENSITY);
+  });
+
+  test('Generic: copyAsLog2Columns copies values without transform', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromList(DG.COLUMN_TYPE.FLOAT, 'Intensity A', [15.2, 18.7]),
+    ]);
+    copyAsLog2Columns(df, ['Intensity A']);
+    const log2Col = df.col('log2(Intensity A)');
+    expect(log2Col !== null, true);
+    if (log2Col) {
+      expect(Math.abs(log2Col.get(0)! - 15.2) < 0.001, true);
+      expect(Math.abs(log2Col.get(1)! - 18.7) < 0.001, true);
+    }
+  });
+
+  test('Generic: addPrimaryColumnIfNeeded creates column for semicolons', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('Protein', ['P12345;Q67890', 'P11111']),
+    ]);
+    addPrimaryColumnIfNeeded(df, 'Protein', 'Primary Protein', SEMTYPE.PROTEIN_ID);
+    const primaryCol = df.col('Primary Protein');
+    expect(primaryCol !== null, true);
+    if (primaryCol) {
+      expect(primaryCol.get(0), 'P12345');
+      expect(primaryCol.get(1), 'P11111');
+    }
+  });
+
+  test('Generic: addPrimaryColumnIfNeeded skips when no semicolons', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('Protein', ['P12345', 'P11111']),
+    ]);
+    addPrimaryColumnIfNeeded(df, 'Protein', 'Primary Protein', SEMTYPE.PROTEIN_ID);
+    const primaryCol = df.col('Primary Protein');
+    expect(primaryCol, null);
+  });
+
+  test('Generic: assigns semantic types to selected columns', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('Protein', ['P12345']),
+    ]);
+    const col = df.col('Protein')!;
+    col.semType = SEMTYPE.PROTEIN_ID;
+    expect(col.semType, SEMTYPE.PROTEIN_ID);
+  });
+});

package/src/tests/group-mean-correlation.ts

@@ -0,0 +1,139 @@
+import * as DG from 'datagrok-api/dg';
+import {category, test, expect} from '@datagrok-libraries/test/src/test';
+import {
+  createGroupMeanCorrelation,
+  computeGroupMeans,
+  pearson,
+  spearman,
+} from '../viewers/group-mean-correlation';
+import {setGroups} from '../analysis/experiment-setup';
+import {SEMTYPE} from '../utils/proteomics-types';
+
+/** Builds a 5-row, 4-sample fixture DataFrame with a `direction` column so the
+ *  correlation viewer's color binding has something to point at. */
+function makeFixtureDf(): DG.DataFrame {
+  const cols: DG.Column[] = [];
+  const pid = DG.Column.fromStrings('Primary Protein ID',
+    ['P1', 'P2', 'P3', 'P4', 'P5']);
+  pid.semType = SEMTYPE.PROTEIN_ID;
+  cols.push(pid);
+
+  const display = DG.Column.fromStrings('Display Name',
+    ['Gene1', 'Gene2', 'Gene3', 'Gene4', 'Gene5']);
+  display.semType = SEMTYPE.DISPLAY_NAME;
+  cols.push(display);
+
+  // Intensities — known per-row mean of [g1,g2] is monotonic for groupMeanColumnsCreated.
+  // Row 0: g1={1,3}→mean=2, g2={5,7}→mean=6
+  // Row 1: g1={2,4}→mean=3, g2={6,8}→mean=7
+  // Row 2: g1={3,5}→mean=4, g2={7,9}→mean=8
+  // Row 3: g1={4,6}→mean=5, g2={8,10}→mean=9
+  // Row 4: g1={5,7}→mean=6, g2={9,11}→mean=10
+  cols.push(DG.Column.fromList('double' as DG.ColumnType, 'S1', [1, 2, 3, 4, 5]));
+  cols.push(DG.Column.fromList('double' as DG.ColumnType, 'S2', [3, 4, 5, 6, 7]));
+  cols.push(DG.Column.fromList('double' as DG.ColumnType, 'S3', [5, 6, 7, 8, 9]));
+  cols.push(DG.Column.fromList('double' as DG.ColumnType, 'S4', [7, 8, 9, 10, 11]));
+
+  // direction column — the viewer reads this for color binding (set by Plan 14-02 ensureDirectionColumn).
+  cols.push(DG.Column.fromStrings('direction',
+    ['Enriched in Control', 'Enriched in Treatment', 'Not significant',
+      'Enriched in Control', 'Enriched in Treatment']));
+
+  const df = DG.DataFrame.fromColumns(cols);
+  setGroups(df, {
+    group1: {name: 'Control', columns: ['S1', 'S2']},
+    group2: {name: 'Treatment', columns: ['S3', 'S4']},
+  });
+  df.name = `correlation-fixture-${Math.random().toString(36).slice(2, 8)}`;
+  return df;
+}
+
+category('Proteomics: 14-04', () => {
+  test('groupMeanColumnsCreated', async () => {
+    const df = makeFixtureDf();
+    computeGroupMeans(df, {
+      group1: {name: 'Control', columns: ['S1', 'S2']},
+      group2: {name: 'Treatment', columns: ['S3', 'S4']},
+    });
+    const num = df.col('Numerator Mean');
+    const den = df.col('Denominator Mean');
+    expect(num !== null, true);
+    expect(den !== null, true);
+    expect(num!.semType, SEMTYPE.NUMERATOR_MEAN);
+    expect(den!.semType, SEMTYPE.DENOMINATOR_MEAN);
+    expect(num!.length, df.rowCount);
+    expect(den!.length, df.rowCount);
+    // Row 0 means: g1=(1+3)/2=2, g2=(5+7)/2=6.
+    expect(Math.abs((num!.get(0) as number) - 2) < 1e-6, true);
+    expect(Math.abs((den!.get(0) as number) - 6) < 1e-6, true);
+    // Row 4 means: g1=(5+7)/2=6, g2=(9+11)/2=10.
+    expect(Math.abs((num!.get(4) as number) - 6) < 1e-6, true);
+    expect(Math.abs((den!.get(4) as number) - 10) < 1e-6, true);
+  });
+
+  test('groupMeanColumnsReRunSafe', async () => {
+    const df = makeFixtureDf();
+    const groups = {
+      group1: {name: 'Control', columns: ['S1', 'S2']},
+      group2: {name: 'Treatment', columns: ['S3', 'S4']},
+    };
+    computeGroupMeans(df, groups);
+    computeGroupMeans(df, groups);
+    // No duplicates after a second invocation.
+    const numCount = df.columns.toList().filter((c) => c.name === 'Numerator Mean').length;
+    const denCount = df.columns.toList().filter((c) => c.name === 'Denominator Mean').length;
+    expect(numCount, 1);
+    expect(denCount, 1);
+    // Values still correct.
+    const num = df.col('Numerator Mean')!;
+    expect(Math.abs((num.get(0) as number) - 2) < 1e-6, true);
+  });
+
+  test('pearsonPerfectCorrelation', async () => {
+    const r = pearson([1, 2, 3, 4, 5], [2, 4, 6, 8, 10]);
+    expect(Math.abs(r - 1) < 1e-9, true);
+  });
+
+  test('pearsonNoCorrelation', async () => {
+    const r = pearson([1, 2, 3, 4, 5], [3, 1, 4, 1, 5]);
+    // Not exactly 0 — just within a reasonable tolerance away from 1.
+    expect(Math.abs(r) < 0.6, true);
+  });
+
+  test('spearmanRankTies', async () => {
+    const rho = spearman([1, 2, 2, 3, 4], [1, 2, 2, 3, 4]);
+    expect(Math.abs(rho - 1) < 1e-9, true);
+  });
+
+  test('createGroupMeanCorrelationFactory', async () => {
+    const df = makeFixtureDf();
+    const sp = createGroupMeanCorrelation(df);
+    expect(sp !== null, true);
+    const opts: any = (sp as any).getOptions?.();
+    const title: string = opts?.look?.title ?? '';
+    expect(title.includes('r='), true);
+    expect(title.includes('ρ='), true);
+    expect(sp.props.xColumnName, 'Numerator Mean');
+    expect(sp.props.yColumnName, 'Denominator Mean');
+    expect(sp.props.colorColumnName, 'direction');
+  });
+
+  test('correlationDiagonalLine', async () => {
+    const df = makeFixtureDf();
+    createGroupMeanCorrelation(df);
+    const lines = df.meta.formulaLines.items;
+    const diagonal = lines.find((l: any) => {
+      const f = (l.formula ?? '') as string;
+      return typeof f === 'string' &&
+        f.includes('Numerator Mean') && f.includes('Denominator Mean');
+    });
+    expect(diagonal !== undefined, true);
+    expect((diagonal as any).color, '#888888');
+  });
+
+  test('correlationLabelBindsToDisplayName', async () => {
+    const df = makeFixtureDf();
+    const sp = createGroupMeanCorrelation(df);
+    expect((sp.props.labelColumnNames as string[])?.includes('Display Name'), true);
+  });
+});

package/src/tests/log2-scale.ts

@@ -0,0 +1,93 @@
+import * as DG from 'datagrok-api/dg';
+import {category, test, expect} from '@datagrok-libraries/test/src/test';
+import {SEMTYPE} from '../utils/proteomics-types';
+import {log2TransformColumns, copyAsLog2Columns} from '../parsers/shared-utils';
+import {getIntensityOriginals, detectCurrentLog2Applied, applyLog2Scale}
+  from '../analysis/log2-scale';
+
+/** DataFrame with two raw intensity samples (semType INTENSITY, no log2 columns
+ * yet). Values are large so they unambiguously round-trip through log2. */
+function makeRawDf(): DG.DataFrame {
+  const df = DG.DataFrame.fromColumns([
+    DG.Column.fromStrings('Protein ID', ['P1', 'P2', 'P3']),
+    DG.Column.fromFloat32Array('Intensity_S1', new Float32Array([1000, 4000, 16000])),
+    DG.Column.fromFloat32Array('Intensity_S2', new Float32Array([2000, 8000, 32000])),
+  ]);
+  df.col('Protein ID')!.semType = SEMTYPE.PROTEIN_ID;
+  df.col('Intensity_S1')!.semType = SEMTYPE.INTENSITY;
+  df.col('Intensity_S2')!.semType = SEMTYPE.INTENSITY;
+  return df;
+}
+
+category('Log2 Scale', () => {
+  test('getIntensityOriginals: only the pristine (non-log2) intensity columns', async () => {
+    const df = makeRawDf();
+    log2TransformColumns(df, ['Intensity_S1', 'Intensity_S2']);
+    const originals = getIntensityOriginals(df);
+    expect(originals.length, 2, 'two originals');
+    expect(originals.includes('Intensity_S1') && originals.includes('Intensity_S2'), true,
+      'includes both raw columns');
+    expect(originals.some((n) => n.startsWith('log2(')), false, 'excludes the log2 copies');
+  });
+
+  test('detectCurrentLog2Applied: transform vs copy is read from the values', async () => {
+    const t = makeRawDf();
+    log2TransformColumns(t, ['Intensity_S1', 'Intensity_S2']);
+    expect(detectCurrentLog2Applied(t, getIntensityOriginals(t)), 'transform',
+      'log2(x) columns read as transform');
+
+    const c = makeRawDf();
+    copyAsLog2Columns(c, ['Intensity_S1', 'Intensity_S2']);
+    expect(detectCurrentLog2Applied(c, getIntensityOriginals(c)), 'copy',
+      'copied columns read as copy');
+  });
+
+  test('applyLog2Scale: transform→copy rebuilds values, clears stale tags, is idempotent', async () => {
+    const df = makeRawDf();
+    log2TransformColumns(df, ['Intensity_S1', 'Intensity_S2']);
+    // Simulate a pipeline that already ran on the (wrong-scale) data.
+    df.setTag('proteomics.normalized', 'true');
+    df.setTag('proteomics.de_complete', 'true');
+    df.setTag('proteomics.de_method', 't-test');
+
+    // log2 transform is currently applied; before flip the copy equals log2(1000).
+    expect(Math.abs(df.col('log2(Intensity_S1)')!.get(0) - Math.log2(1000)) < 1e-3, true,
+      'starts transformed');
+
+    // Flip to "already log2" → copies the raw value straight through.
+    const changed = applyLog2Scale(df, true);
+    expect(changed, true, 'a real scale change returns true');
+    expect(df.col('log2(Intensity_S1)')!.get(0), 1000, 'value is now the raw copy');
+    expect(detectCurrentLog2Applied(df, getIntensityOriginals(df)), 'copy', 'now reads as copy');
+
+    // Stale downstream state is cleared so viewers re-gate.
+    expect(df.getTag('proteomics.normalized') || '', '', 'normalized tag cleared');
+    expect(df.getTag('proteomics.de_complete') || '', '', 'de_complete tag cleared');
+    expect(df.getTag('proteomics.de_method') || '', '', 'de_method tag cleared');
+
+    // No original columns were duplicated by the rebuild.
+    expect(getIntensityOriginals(df).length, 2, 'still exactly two originals');
+
+    // Re-applying the same scale is a no-op.
+    expect(applyLog2Scale(df, true), false, 'no-op when scale already matches returns false');
+  });
+
+  test('applyLog2Scale: copy→transform restores the log2 transform', async () => {
+    const df = makeRawDf();
+    copyAsLog2Columns(df, ['Intensity_S1', 'Intensity_S2']);
+    const changed = applyLog2Scale(df, false);
+    expect(changed, true, 'scale change returns true');
+    expect(Math.abs(df.col('log2(Intensity_S2)')!.get(2) - Math.log2(32000)) < 1e-3, true,
+      'transform re-applied to raw value');
+    expect(detectCurrentLog2Applied(df, getIntensityOriginals(df)), 'transform', 'reads as transform');
+  });
+
+  test('getIntensityOriginals: empty when no intensity columns', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('Protein ID', ['P1', 'P2']),
+    ]);
+    df.col('Protein ID')!.semType = SEMTYPE.PROTEIN_ID;
+    expect(getIntensityOriginals(df).length, 0, 'no originals');
+    expect(applyLog2Scale(df, true), false, 'applyLog2Scale is a no-op with nothing to rescale');
+  });
+});

package/src/tests/organisms.ts

@@ -0,0 +1,56 @@
+import * as DG from 'datagrok-api/dg';
+import {category, test, expect} from '@datagrok-libraries/test/src/test';
+import {resolveOrganismCode, detectOrganismCode, ORGANISM_LIST} from '../utils/organisms';
+
+function dfWithOrganismColumn(name: string, values: string[]): DG.DataFrame {
+  return DG.DataFrame.fromColumns([DG.Column.fromStrings(name, values)]);
+}
+
+category('Organisms', () => {
+  test('resolveOrganismCode maps scientific names (incl. strain-qualified) to codes', async () => {
+    expect(resolveOrganismCode('Homo sapiens'), 'hsapiens');
+    expect(resolveOrganismCode('Rattus norvegicus'), 'rnorvegicus');
+    // Strain-qualified values still resolve via the scientific-name prefix.
+    expect(resolveOrganismCode('Escherichia coli (strain K12)'), 'ecoli');
+    expect(resolveOrganismCode('Saccharomyces cerevisiae (strain ATCC 204508 / S288c)'), 'scerevisiae');
+  });
+
+  test('resolveOrganismCode returns undefined for unsupported / empty', async () => {
+    expect(resolveOrganismCode('Sus scrofa') === undefined, true);
+    expect(resolveOrganismCode('') === undefined, true);
+    expect(resolveOrganismCode(null) === undefined, true);
+    expect(resolveOrganismCode(undefined) === undefined, true);
+  });
+
+  test('every ORGANISM_LIST display resolves back to its own code', async () => {
+    for (const o of ORGANISM_LIST)
+      expect(resolveOrganismCode(o.display), o.code);
+  });
+
+  test('detectOrganismCode: single-species PG.Organisms column → that code', async () => {
+    const df = dfWithOrganismColumn('PG.Organisms',
+      ['Rattus norvegicus', 'Rattus norvegicus', 'Rattus norvegicus']);
+    expect(detectOrganismCode(df), 'rnorvegicus');
+  });
+
+  test('detectOrganismCode: works on a generically named "Organism" column', async () => {
+    const df = dfWithOrganismColumn('Organism', ['Homo sapiens', 'Homo sapiens']);
+    expect(detectOrganismCode(df), 'hsapiens');
+  });
+
+  test('detectOrganismCode: mixed empties/unknowns but one species → that code', async () => {
+    const df = dfWithOrganismColumn('PG.Organisms', ['', 'Homo sapiens', 'Sus scrofa', '']);
+    expect(detectOrganismCode(df), 'hsapiens');
+  });
+
+  test('detectOrganismCode: multi-species (HYE-style mix) → undefined (do not guess)', async () => {
+    const df = dfWithOrganismColumn('PG.Organisms',
+      ['Homo sapiens', 'Escherichia coli (strain K12)', 'Saccharomyces cerevisiae']);
+    expect(detectOrganismCode(df) === undefined, true);
+  });
+
+  test('detectOrganismCode: no organism column → undefined', async () => {
+    const df = DG.DataFrame.fromColumns([DG.Column.fromStrings('Gene', ['CDK1', 'CCNB1'])]);
+    expect(detectOrganismCode(df) === undefined, true);
+  });
+});

package/src/tests/parsers.ts

@@ -0,0 +1,182 @@
+import * as DG from 'datagrok-api/dg';
+import {category, test, expect} from '@datagrok-libraries/test/src/test';
+import {parseMaxQuantText} from '../parsers/maxquant-parser';
+import {SEMTYPE} from '../utils/proteomics-types';
+
+// Helper: build a minimal proteinGroups TSV for testing
+function makeTsv(rows: string[][], headers: string[]): string {
+  return [headers.join('\t'), ...rows.map((r) => r.join('\t'))].join('\n');
+}
+
+const HEADERS = [
+  'Protein IDs', 'Majority protein IDs', 'Gene names',
+  'Potential contaminant', 'Reverse', 'Only identified by site',
+  'LFQ intensity Sample1', 'LFQ intensity Sample2', 'iBAQ',
+];
+
+category('Parsers', () => {
+  test('MaxQuant: filters contaminant rows', async () => {
+    const tsv = makeTsv([
+      ['P12345', 'P12345', 'BRCA1', '', '', '', '1000', '2000', '500'],
+      ['P99999', 'P99999', 'TP53', '+', '', '', '3000', '4000', '600'],
+    ], HEADERS);
+    const df = await parseMaxQuantText(tsv);
+    expect(df.rowCount, 1);
+  });
+
+  test('MaxQuant: filters reverse rows', async () => {
+    const tsv = makeTsv([
+      ['P12345', 'P12345', 'BRCA1', '', '', '', '1000', '2000', '500'],
+      ['P99999', 'P99999', 'TP53', '', '+', '', '3000', '4000', '600'],
+    ], HEADERS);
+    const df = await parseMaxQuantText(tsv);
+    expect(df.rowCount, 1);
+  });
+
+  test('MaxQuant: filters only-by-site rows', async () => {
+    const tsv = makeTsv([
+      ['P12345', 'P12345', 'BRCA1', '', '', '', '1000', '2000', '500'],
+      ['P99999', 'P99999', 'TP53', '', '', '+', '3000', '4000', '600'],
+    ], HEADERS);
+    const df = await parseMaxQuantText(tsv);
+    expect(df.rowCount, 1);
+  });
+
+  test('MaxQuant: filters CON__ prefix rows', async () => {
+    const tsv = makeTsv([
+      ['P12345', 'P12345', 'BRCA1', '', '', '', '1000', '2000', '500'],
+      ['CON__P99999', 'CON__P99999', 'KRT1', '', '', '', '3000', '4000', '600'],
+    ], HEADERS);
+    const df = await parseMaxQuantText(tsv);
+    expect(df.rowCount, 1);
+  });
+
+  test('MaxQuant: filters REV__ prefix rows', async () => {
+    const tsv = makeTsv([
+      ['P12345', 'P12345', 'BRCA1', '', '', '', '1000', '2000', '500'],
+      ['REV__P99999', 'REV__P99999', 'TP53', '', '', '', '3000', '4000', '600'],
+    ], HEADERS);
+    const df = await parseMaxQuantText(tsv);
+    expect(df.rowCount, 1);
+  });
+
+  test('MaxQuant: detects LFQ intensity columns', async () => {
+    const tsv = makeTsv([
+      ['P12345', 'P12345', 'BRCA1', '', '', '', '1000', '2000', '500'],
+    ], HEADERS);
+    const df = await parseMaxQuantText(tsv);
+    expect(df.col('LFQ intensity Sample1') !== null, true);
+    expect(df.col('log2(LFQ intensity Sample1)') !== null, true);
+    expect(df.col('log2(LFQ intensity Sample2)') !== null, true);
+  });
+
+  test('MaxQuant: log2 transforms intensity values correctly', async () => {
+    const tsv = makeTsv([
+      ['P12345', 'P12345', 'BRCA1', '', '', '', '1024', '2048', '500'],
+    ], HEADERS);
+    const df = await parseMaxQuantText(tsv);
+    const log2Col = df.col('log2(LFQ intensity Sample1)');
+    expect(log2Col !== null, true);
+    if (log2Col)
+      expect(Math.abs(log2Col.get(0)! - 10.0) < 0.001, true);
+  });
+
+  test('MaxQuant: zero intensity produces FLOAT_NULL in log2', async () => {
+    const tsv = makeTsv([
+      ['P12345', 'P12345', 'BRCA1', '', '', '', '0', '2048', '500'],
+    ], HEADERS);
+    const df = await parseMaxQuantText(tsv);
+    const log2Col = df.col('log2(LFQ intensity Sample1)');
+    expect(log2Col !== null, true);
+    if (log2Col)
+      expect(log2Col.isNone(0), true);
+  });
+
+  test('MaxQuant: assigns semantic types', async () => {
+    const tsv = makeTsv([
+      ['P12345', 'P12345', 'BRCA1', '', '', '', '1000', '2000', '500'],
+    ], HEADERS);
+    const df = await parseMaxQuantText(tsv);
+    expect(df.col('Protein IDs')?.semType, SEMTYPE.PROTEIN_ID);
+    expect(df.col('Gene names')?.semType, SEMTYPE.GENE_SYMBOL);
+    expect(df.col('LFQ intensity Sample1')?.semType, SEMTYPE.INTENSITY);
+    expect(df.col('log2(LFQ intensity Sample1)')?.semType, SEMTYPE.INTENSITY);
+  });
+
+  test('MaxQuant: parses primary protein ID from semicolon-delimited', async () => {
+    const tsv = makeTsv([
+      ['P12345;Q67890;R11111', 'P12345', 'BRCA1;BRCA2', '', '', '', '1000', '2000', '500'],
+    ], HEADERS);
+    const df = await parseMaxQuantText(tsv);
+    const primaryId = df.col('Primary Protein ID');
+    expect(primaryId !== null, true);
+    if (primaryId)
+      expect(primaryId.get(0), 'P12345');
+    const primaryGene = df.col('Primary Gene Name');
+    expect(primaryGene !== null, true);
+    if (primaryGene)
+      expect(primaryGene.get(0), 'BRCA1');
+  });
+
+  test('MaxQuant: no contaminant IDs remain after filtering', async () => {
+    const tsv = makeTsv([
+      ['P12345', 'P12345', 'BRCA1', '', '', '', '1000', '2000', '500'],
+      ['P22222', 'P22222', 'TP53', '', '', '', '3000', '4000', '600'],
+      ['CON__P99999', 'CON__P99999', 'KRT1', '+', '', '', '5000', '6000', '700'],
+      ['REV__P88888', 'REV__P88888', 'FAKE1', '', '+', '', '7000', '8000', '800'],
+      ['P77777', 'P77777', 'FAKE2', '', '', '+', '9000', '1000', '900'],
+    ], HEADERS);
+    const df = await parseMaxQuantText(tsv);
+    expect(df.rowCount, 2);
+    const idCol = df.col('Protein IDs')!;
+    for (let i = 0; i < df.rowCount; i++) {
+      const val = idCol.get(i) as string;
+      if (val.startsWith('CON__') || val.startsWith('REV__'))
+        throw new Error(`Found filtered ID in output: ${val}`);
+    }
+  });
+
+  test('MaxQuant: assigns intensity semantic type to log2 columns', async () => {
+    const tsv = makeTsv([
+      ['P12345', 'P12345', 'BRCA1', '', '', '', '1000', '2000', '500'],
+    ], HEADERS);
+    const df = await parseMaxQuantText(tsv);
+    expect(df.col('log2(LFQ intensity Sample1)')?.semType, SEMTYPE.INTENSITY);
+    expect(df.col('log2(LFQ intensity Sample2)')?.semType, SEMTYPE.INTENSITY);
+    expect(df.col('log2(iBAQ)')?.semType, SEMTYPE.INTENSITY);
+  });
+
+  test('MaxQuant: handles MQ 2.x dot column names', async () => {
+    const headers2x = [
+      'Protein IDs', 'Majority protein IDs', 'Gene names',
+      'Potential.contaminant', 'Reverse', 'Only.identified.by.site',
+      'LFQ intensity Sample1',
+    ];
+    const tsv = makeTsv([
+      ['P12345', 'P12345', 'BRCA1', '', '', '', '1000'],
+      ['P99999', 'P99999', 'TP53', '+', '', '', '3000'],
+    ], headers2x);
+    const df = await parseMaxQuantText(tsv);
+    expect(df.rowCount, 1);
+  });
+
+  test('MaxQuant: parser tags proteomics.source', async () => {
+    // parseMaxQuantText does NOT set df.name — that's the caller's job (importMaxQuant
+    // derives it from the filename). The parser DOES tag proteomics.source so
+    // downstream pipeline steps can identify the import origin.
+    const tsv = makeTsv([
+      ['P12345', 'P12345', 'BRCA1', '', '', '', '1000', '2000', '500'],
+    ], HEADERS);
+    const df = await parseMaxQuantText(tsv);
+    expect(df.getTag('proteomics.source'), 'maxquant');
+  });
+
+  test('MaxQuant: iBAQ columns detected as intensity', async () => {
+    const tsv = makeTsv([
+      ['P12345', 'P12345', 'BRCA1', '', '', '', '1000', '2000', '500'],
+    ], HEADERS);
+    const df = await parseMaxQuantText(tsv);
+    expect(df.col('iBAQ')?.semType, SEMTYPE.INTENSITY);
+    expect(df.col('log2(iBAQ)') !== null, true);
+  });
+});