@morscherlab/mint-sdk 1.0.0-alpha.2

package/src/__tests__/composables/useAutoGroup.test.ts

@@ -0,0 +1,860 @@
+import { describe, it, expect } from 'vitest'
+import {
+  analyzeDelimiter,
+  detectOutliers,
+  classifyOutlierAction,
+  extractColumns,
+  parseCSV,
+  parseCSVLine,
+  computeGroups,
+  computeGroupsFromCsv,
+  extractSamplesFromDesignData,
+  DEFAULT_COLORS,
+  useAutoGroup,
+} from '../../composables/useAutoGroup'
+import type { OutlierAction } from '../../types/auto-group'
+
+describe('analyzeDelimiter', () => {
+  it('should detect underscore delimiter', () => {
+    const lines = ['Ctrl_WT_1', 'Ctrl_WT_2', 'Treat_KO_1', 'Treat_KO_2']
+    const result = analyzeDelimiter(lines)
+    expect(result.delimiter).toBe('_')
+    expect(result.dominantFieldCount).toBe(3)
+    expect(result.consistency).toBe(1)
+  })
+
+  it('should detect hyphen delimiter', () => {
+    const lines = ['Ctrl-WT-1', 'Ctrl-WT-2', 'Treat-KO-1']
+    const result = analyzeDelimiter(lines)
+    expect(result.delimiter).toBe('-')
+    expect(result.dominantFieldCount).toBe(3)
+  })
+
+  it('should detect dot delimiter', () => {
+    const lines = ['Ctrl.WT.1', 'Ctrl.WT.2', 'Treat.KO.1']
+    const result = analyzeDelimiter(lines)
+    expect(result.delimiter).toBe('.')
+    expect(result.dominantFieldCount).toBe(3)
+  })
+
+  it('should pick most consistent delimiter with mixed usage', () => {
+    // Underscores used consistently (3 fields), hyphens appear but less consistently
+    const lines = ['Ctrl_WT_1', 'Ctrl_WT_2', 'Treat_KO-1', 'Treat_KO_2']
+    const result = analyzeDelimiter(lines)
+    expect(result.delimiter).toBe('_')
+  })
+
+  it('should prefer underscore when tied', () => {
+    // Both _ and - produce identical consistency
+    const lines = ['A_B-C']
+    const result = analyzeDelimiter(lines)
+    expect(result.delimiter).toBe('_')
+  })
+
+  it('should handle single-segment samples (no delimiter)', () => {
+    const lines = ['SampleA', 'SampleB', 'SampleC']
+    const result = analyzeDelimiter(lines)
+    expect(result.dominantFieldCount).toBe(1)
+    expect(result.minFieldCount).toBe(1)
+  })
+
+  it('should handle empty input', () => {
+    const result = analyzeDelimiter([])
+    expect(result.delimiter).toBe('_')
+    expect(result.dominantFieldCount).toBe(1)
+    expect(result.minFieldCount).toBe(1)
+    expect(result.consistency).toBe(0)
+  })
+
+  it('should compute correct consistency ratio', () => {
+    // 3 out of 4 samples have 3 fields with underscore
+    const lines = ['A_B_C', 'D_E_F', 'G_H_I', 'JK']
+    const result = analyzeDelimiter(lines)
+    expect(result.delimiter).toBe('_')
+    expect(result.dominantFieldCount).toBe(3)
+    expect(result.consistency).toBe(0.75)
+  })
+
+  it('should return correct minFieldCount with mixed field counts', () => {
+    const lines = ['Control_Rep1', 'Treatment_Low_Rep1', 'Vehicle_Rep1']
+    const result = analyzeDelimiter(lines)
+    expect(result.delimiter).toBe('_')
+    expect(result.minFieldCount).toBe(2)
+    expect(result.dominantFieldCount).toBe(2)
+  })
+
+  it('should return minFieldCount different from dominantFieldCount when needed', () => {
+    const lines = [
+      'Control_Rep1', 'Control_Rep2',
+      'Treatment_Low_Rep1', 'Treatment_Low_Rep2', 'Treatment_Low_Rep3',
+      'Treatment_High_Rep1', 'Treatment_High_Rep2', 'Treatment_High_Rep3',
+    ]
+    const result = analyzeDelimiter(lines)
+    expect(result.delimiter).toBe('_')
+    // Mode is 3 (6 samples have 3 fields vs 2 samples with 2 fields)
+    expect(result.dominantFieldCount).toBe(3)
+    // Min of multi-field counts is 2
+    expect(result.minFieldCount).toBe(2)
+  })
+})
+
+describe('detectOutliers', () => {
+  it('should flag samples with fewer fields than minFieldCount', () => {
+    const lines = ['Ctrl_WT_1', 'Ctrl_WT_2', 'QC_Pool', 'Treat_KO_1']
+    const outliers = detectOutliers(lines, '_', 3)
+    expect(outliers).toHaveLength(1)
+    expect(outliers[0].sample).toBe('QC_Pool')
+    expect(outliers[0].index).toBe(2)
+    expect(outliers[0].fieldCount).toBe(2)
+    expect(outliers[0].action).toBe('include')
+  })
+
+  it('should return empty array when all meet minFieldCount', () => {
+    const lines = ['A_B_C', 'D_E_F', 'G_H_I']
+    const outliers = detectOutliers(lines, '_', 3)
+    expect(outliers).toHaveLength(0)
+  })
+
+  it('should preserve original line index', () => {
+    const lines = ['A_B', 'C', 'D_E', 'F']
+    const outliers = detectOutliers(lines, '_', 2)
+    expect(outliers).toHaveLength(2)
+    expect(outliers[0]).toEqual({ sample: 'C', index: 1, fieldCount: 1, action: 'include' })
+    expect(outliers[1]).toEqual({ sample: 'F', index: 3, fieldCount: 1, action: 'include' })
+  })
+
+  it('should NOT flag samples with more fields than minFieldCount', () => {
+    const lines = ['Ctrl_Rep1', 'Treat_Low_Rep1']
+    const outliers = detectOutliers(lines, '_', 2)
+    expect(outliers).toHaveLength(0)
+  })
+
+  it('should flag single-segment samples when minFieldCount requires delimiter', () => {
+    const lines = ['Ctrl_Rep1', 'QCPool']
+    const outliers = detectOutliers(lines, '_', 2)
+    expect(outliers).toHaveLength(1)
+    expect(outliers[0].sample).toBe('QCPool')
+    expect(outliers[0].fieldCount).toBe(1)
+  })
+
+  it('should not flag any sample when minFieldCount is 1', () => {
+    const lines = ['ABC', 'DEF', 'G_H_I']
+    const outliers = detectOutliers(lines, '_', 1)
+    expect(outliers).toHaveLength(0)
+  })
+})
+
+describe('extractColumns', () => {
+  it('should produce correct column count and unique values via right alignment', () => {
+    const samples = ['Ctrl_Liver_1', 'Ctrl_Brain_2', 'Treat_Liver_1']
+    const columns = extractColumns(samples, '_', 3)
+    expect(columns).toHaveLength(3)
+    expect(columns[0].uniqueValues).toEqual(['Ctrl', 'Treat'])
+    expect(columns[1].uniqueValues).toEqual(['Liver', 'Brain'])
+    expect(columns[2].uniqueValues).toEqual(['1', '2'])
+  })
+
+  it('should compute correct cardinality', () => {
+    const samples = ['A_X_1', 'A_Y_2', 'B_X_1', 'B_Y_2']
+    const columns = extractColumns(samples, '_', 3)
+    expect(columns[0].cardinality).toBe(2) // A, B
+    expect(columns[1].cardinality).toBe(2) // X, Y
+    expect(columns[2].cardinality).toBe(2) // 1, 2
+  })
+
+  it('should assign Condition as first column name and Field N for rest', () => {
+    const samples = ['A_B_C']
+    const columns = extractColumns(samples, '_', 3)
+    expect(columns[0].name).toBe('Condition')
+    expect(columns[1].name).toBe('Field 2')
+    expect(columns[2].name).toBe('Field 3')
+  })
+
+  it('should set correct column indices', () => {
+    const samples = ['A_B_C_D']
+    const columns = extractColumns(samples, '_', 4)
+    expect(columns.map(c => c.index)).toEqual([0, 1, 2, 3])
+  })
+
+  it('should handle empty input', () => {
+    const columns = extractColumns([], '_', 2)
+    expect(columns).toHaveLength(0)
+  })
+
+  it('should handle variable-length prefixes via right alignment', () => {
+    const samples = ['Control_Rep1', 'Treatment_Low_Rep1', 'Vehicle_Rep1']
+    const columns = extractColumns(samples, '_', 2)
+    expect(columns).toHaveLength(2)
+    expect(columns[0].uniqueValues).toEqual(['Control', 'Treatment_Low', 'Vehicle'])
+    expect(columns[1].uniqueValues).toEqual(['Rep1'])
+  })
+
+  it('should right-align with 3+ suffix fields', () => {
+    const samples = ['A_X_1', 'B_C_X_1']
+    const columns = extractColumns(samples, '_', 3)
+    expect(columns).toHaveLength(3)
+    expect(columns[0].uniqueValues).toEqual(['A', 'B_C'])
+    expect(columns[1].uniqueValues).toEqual(['X'])
+    expect(columns[2].uniqueValues).toEqual(['1'])
+  })
+
+  it('should mark column types (prefix vs suffix)', () => {
+    const samples = ['A_B_C']
+    const columns = extractColumns(samples, '_', 3)
+    expect(columns[0].type).toBe('prefix')
+    expect(columns[1].type).toBe('suffix')
+    expect(columns[2].type).toBe('suffix')
+  })
+})
+
+describe('parseCSVLine', () => {
+  it('should parse simple comma-separated line', () => {
+    expect(parseCSVLine('A,B,C')).toEqual(['A', 'B', 'C'])
+  })
+
+  it('should handle quoted fields with commas', () => {
+    expect(parseCSVLine('A,"B,C",D')).toEqual(['A', 'B,C', 'D'])
+  })
+
+  it('should trim whitespace from fields', () => {
+    expect(parseCSVLine(' A , B , C ')).toEqual(['A', 'B', 'C'])
+  })
+
+  it('should parse tab-separated line when delimiter is tab', () => {
+    expect(parseCSVLine('A\tB\tC', '\t')).toEqual(['A', 'B', 'C'])
+  })
+})
+
+describe('parseCSV', () => {
+  it('should parse simple CSV with headers', () => {
+    const text = 'Sample,Condition,Tissue\nS1,Ctrl,Liver\nS2,Treat,Brain'
+    const result = parseCSV(text)
+    expect(result.columns).toEqual(['Sample', 'Condition', 'Tissue'])
+    expect(result.rows).toHaveLength(2)
+    expect(result.rows[0]).toEqual({ Sample: 'S1', Condition: 'Ctrl', Tissue: 'Liver' })
+  })
+
+  it('should auto-detect sample column by "sample" header', () => {
+    const text = 'Condition,Sample,Tissue\nCtrl,S1,Liver'
+    const result = parseCSV(text)
+    expect(result.sampleColumn).toBe('Sample')
+  })
+
+  it('should auto-detect sample column by "name" header', () => {
+    const text = 'Name,Group\nS1,A\nS2,B'
+    const result = parseCSV(text)
+    expect(result.sampleColumn).toBe('Name')
+  })
+
+  it('should auto-detect sample column by "id" header', () => {
+    const text = 'ID,Group\nS1,A'
+    const result = parseCSV(text)
+    expect(result.sampleColumn).toBe('ID')
+  })
+
+  it('should fall back to first column when no recognized header', () => {
+    const text = 'Foo,Bar,Baz\n1,2,3'
+    const result = parseCSV(text)
+    expect(result.sampleColumn).toBe('Foo')
+  })
+
+  it('should handle quoted fields with commas', () => {
+    const text = 'Sample,Description\nS1,"Long, complex name"\nS2,Simple'
+    const result = parseCSV(text)
+    expect(result.rows[0].Description).toBe('Long, complex name')
+  })
+
+  it('should reject CSV with fewer than 2 lines', () => {
+    expect(() => parseCSV('Header1,Header2')).toThrow()
+    expect(() => parseCSV('')).toThrow()
+  })
+
+  it('should auto-detect tab-separated files', () => {
+    const text = 'File Name\tTreatment Group\nSample_001\tCtrl\nSample_002\tTreat'
+    const result = parseCSV(text)
+    expect(result.columns).toEqual(['File Name', 'Treatment Group'])
+    expect(result.rows).toHaveLength(2)
+    expect(result.rows[0]).toEqual({ 'File Name': 'Sample_001', 'Treatment Group': 'Ctrl' })
+    expect(result.sampleColumn).toBe('File Name')
+  })
+
+  it('should auto-detect "file name" as sample column', () => {
+    const text = 'File Name,Group\nS1,A\nS2,B'
+    const result = parseCSV(text)
+    expect(result.sampleColumn).toBe('File Name')
+  })
+})
+
+describe('computeGroups', () => {
+  it('should group by single column', () => {
+    const samples = ['Ctrl_Liver_1', 'Ctrl_Brain_2', 'Treat_Liver_1']
+    const columns = extractColumns(samples, '_', 3)
+    const enabledFields = new Set([0]) // group by first column only
+
+    const result = computeGroups(samples, columns, enabledFields, new Map(), '_', 3)
+    expect(result.groups).toHaveLength(2)
+
+    const ctrlGroup = result.groups.find(g => g.name === 'Ctrl')
+    const treatGroup = result.groups.find(g => g.name === 'Treat')
+    expect(ctrlGroup?.samples).toEqual(['Ctrl_Liver_1', 'Ctrl_Brain_2'])
+    expect(treatGroup?.samples).toEqual(['Treat_Liver_1'])
+  })
+
+  it('should group by multiple columns joined with " / "', () => {
+    const samples = ['Ctrl_Liver_1', 'Ctrl_Brain_2', 'Treat_Liver_1']
+    const columns = extractColumns(samples, '_', 3)
+    const enabledFields = new Set([0, 1])
+
+    const result = computeGroups(samples, columns, enabledFields, new Map(), '_', 3)
+    expect(result.groups).toHaveLength(3)
+
+    const names = result.groups.map(g => g.name).sort()
+    expect(names).toEqual(['Ctrl / Brain', 'Ctrl / Liver', 'Treat / Liver'])
+  })
+
+  it('should cycle colors from DEFAULT_COLORS', () => {
+    const samples = Array.from({ length: 12 }, (_, i) => `G${i}_X`)
+    const columns = extractColumns(samples, '_', 2)
+    const enabledFields = new Set([0])
+
+    const result = computeGroups(samples, columns, enabledFields, new Map(), '_', 2)
+    // 12 unique groups should cycle through 10 colors
+    expect(result.groups[0].color).toBe(DEFAULT_COLORS[0])
+    expect(result.groups[10].color).toBe(DEFAULT_COLORS[0])
+    expect(result.groups[11].color).toBe(DEFAULT_COLORS[1])
+  })
+
+  it('should exclude outliers marked as "exclude"', () => {
+    const samples = ['Ctrl_WT_1', 'Ctrl_WT_2', 'QC_Pool']
+    const columns = extractColumns(['Ctrl_WT_1', 'Ctrl_WT_2'], '_', 3)
+    const enabledFields = new Set([0])
+    const outlierActions = new Map<number, OutlierAction>([[2, 'exclude']])
+
+    const result = computeGroups(samples, columns, enabledFields, outlierActions, '_', 3)
+    expect(result.excludedSamples).toContain('QC_Pool')
+    const allGroupedSamples = result.groups.flatMap(g => g.samples)
+    expect(allGroupedSamples).not.toContain('QC_Pool')
+  })
+
+  it('should put QC-marked outliers in a QC group', () => {
+    const samples = ['Ctrl_WT_1', 'Ctrl_WT_2', 'QC_Pool']
+    const columns = extractColumns(['Ctrl_WT_1', 'Ctrl_WT_2'], '_', 3)
+    const enabledFields = new Set([0])
+    const outlierActions = new Map<number, OutlierAction>([[2, 'qc']])
+
+    const result = computeGroups(samples, columns, enabledFields, outlierActions, '_', 3)
+    const qcGroup = result.groups.find(g => g.name === 'QC')
+    expect(qcGroup).toBeDefined()
+    expect(qcGroup?.samples).toContain('QC_Pool')
+    expect(qcGroup?.color).toBe('#6B7280')
+  })
+
+  it('should generate metadata rows', () => {
+    const samples = ['Ctrl_Liver_1', 'Treat_Brain_2']
+    const columns = extractColumns(samples, '_', 3)
+    // Rename columns for metadata
+    columns[0].name = 'Condition'
+    columns[1].name = 'Tissue'
+    columns[2].name = 'Replicate'
+    const enabledFields = new Set([0, 1])
+
+    const result = computeGroups(samples, columns, enabledFields, new Map(), '_', 3)
+    expect(result.metadata).toHaveLength(2)
+    expect(result.metadata[0]).toEqual({
+      sampleName: 'Ctrl_Liver_1',
+      fields: { Condition: 'Ctrl', Tissue: 'Liver', Replicate: '1' },
+      group: 'Ctrl / Liver',
+    })
+  })
+
+  it('should handle single column without separator in group name', () => {
+    const samples = ['A_1', 'B_2', 'A_3']
+    const columns = extractColumns(samples, '_', 2)
+    const enabledFields = new Set([0])
+
+    const result = computeGroups(samples, columns, enabledFields, new Map(), '_', 2)
+    const names = result.groups.map(g => g.name)
+    expect(names).toContain('A')
+    expect(names).toContain('B')
+    // Should NOT contain " / " separator
+    expect(names.every(n => !n.includes(' / '))).toBe(true)
+  })
+
+  it('should correctly group variable-length prefixes', () => {
+    const samples = [
+      'Control_Rep1', 'Control_Rep2', 'Control_Rep3',
+      'Treatment_Low_Rep1', 'Treatment_Low_Rep2', 'Treatment_Low_Rep3',
+    ]
+    const columns = extractColumns(samples, '_', 2)
+    const enabledFields = new Set([0])
+
+    const result = computeGroups(samples, columns, enabledFields, new Map(), '_', 2)
+    expect(result.groups).toHaveLength(2)
+
+    const ctrlGroup = result.groups.find(g => g.name === 'Control')
+    const treatGroup = result.groups.find(g => g.name === 'Treatment_Low')
+    expect(ctrlGroup?.samples).toHaveLength(3)
+    expect(treatGroup?.samples).toHaveLength(3)
+  })
+})
+
+describe('classifyOutlierAction', () => {
+  it('should return qc for samples containing QC keywords', () => {
+    expect(classifyOutlierAction('LT_13102025_EQC_Jurkat_1_2', '_')).toBe('qc')
+    expect(classifyOutlierAction('LT_13102025_IQC_Pool_1', '_')).toBe('qc')
+    expect(classifyOutlierAction('Blank_001', '_')).toBe('qc')
+    expect(classifyOutlierAction('STD_Low_1', '_')).toBe('qc')
+    expect(classifyOutlierAction('test_EQC_Jurkat_02', '_')).toBe('qc')
+  })
+
+  it('should match case-insensitively', () => {
+    expect(classifyOutlierAction('LT_eqc_Pool', '_')).toBe('qc')
+    expect(classifyOutlierAction('LT_EQC_Pool', '_')).toBe('qc')
+    expect(classifyOutlierAction('LT_Eqc_Pool', '_')).toBe('qc')
+    expect(classifyOutlierAction('BLANK_001', '_')).toBe('qc')
+    expect(classifyOutlierAction('Test_Sample', '_')).toBe('qc')
+  })
+
+  it('should match against individual segments only', () => {
+    // "eqc" embedded inside a segment should NOT match
+    expect(classifyOutlierAction('LT_SEQC123_Pool', '_')).toBe('include')
+    // "std" as standalone segment should match
+    expect(classifyOutlierAction('LT_std_Pool', '_')).toBe('qc')
+  })
+
+  it('should return include for regular experimental samples', () => {
+    expect(classifyOutlierAction('LT_13102025_212_WT_Glu', '_')).toBe('include')
+    expect(classifyOutlierAction('Control_Rep1', '_')).toBe('include')
+    expect(classifyOutlierAction('Treatment_High_Rep3', '_')).toBe('include')
+  })
+
+  it('should work with different delimiters', () => {
+    expect(classifyOutlierAction('LT-EQC-Pool', '-')).toBe('qc')
+    expect(classifyOutlierAction('blank.001', '.')).toBe('qc')
+    expect(classifyOutlierAction('Control-Rep1', '-')).toBe('include')
+  })
+})
+
+describe('computeGroupsFromCsv', () => {
+  it('should group samples by CSV column values', () => {
+    const csvData = parseCSV(
+      'File Name\tTreatment Group\n' +
+      'Sample_001\tCtrl\n' +
+      'Sample_002\tCtrl\n' +
+      'Sample_003\tTreat\n' +
+      'Sample_004\tTreat\n'
+    )
+    const columns = [
+      { index: 0, name: 'Treatment Group', uniqueValues: ['Ctrl', 'Treat'], cardinality: 2 },
+    ]
+    const result = computeGroupsFromCsv(csvData, columns, new Set([0]))
+    expect(result.groups).toHaveLength(2)
+
+    const ctrl = result.groups.find(g => g.name === 'Ctrl')
+    const treat = result.groups.find(g => g.name === 'Treat')
+    expect(ctrl?.samples).toEqual(['Sample_001', 'Sample_002'])
+    expect(treat?.samples).toEqual(['Sample_003', 'Sample_004'])
+    expect(result.excludedSamples).toEqual([])
+  })
+
+  it('should group by multiple enabled CSV columns', () => {
+    const csvData = parseCSV(
+      'Sample,Condition,Tissue\nS1,Ctrl,Liver\nS2,Ctrl,Brain\nS3,Treat,Liver'
+    )
+    const columns = [
+      { index: 0, name: 'Condition', uniqueValues: ['Ctrl', 'Treat'], cardinality: 2 },
+      { index: 1, name: 'Tissue', uniqueValues: ['Liver', 'Brain'], cardinality: 2 },
+    ]
+    const result = computeGroupsFromCsv(csvData, columns, new Set([0, 1]))
+    expect(result.groups).toHaveLength(3)
+
+    const names = result.groups.map(g => g.name).sort()
+    expect(names).toEqual(['Ctrl / Brain', 'Ctrl / Liver', 'Treat / Liver'])
+  })
+
+  it('should generate metadata rows from CSV data', () => {
+    const csvData = parseCSV(
+      'Sample,Condition,Tissue\nS1,Ctrl,Liver\nS2,Treat,Brain'
+    )
+    const columns = [
+      { index: 0, name: 'Condition', uniqueValues: ['Ctrl', 'Treat'], cardinality: 2 },
+      { index: 1, name: 'Tissue', uniqueValues: ['Liver', 'Brain'], cardinality: 2 },
+    ]
+    const result = computeGroupsFromCsv(csvData, columns, new Set([0]))
+    expect(result.metadata).toHaveLength(2)
+    expect(result.metadata[0]).toEqual({
+      sampleName: 'S1',
+      fields: { Condition: 'Ctrl', Tissue: 'Liver' },
+      group: 'Ctrl',
+    })
+  })
+
+  it('should still group correctly after user renames a field', () => {
+    const csvData = parseCSV(
+      'Sample,Condition,Tissue\nS1,Ctrl,Liver\nS2,Treat,Brain'
+    )
+    // Simulate user renaming "Condition" to "Treatment" in the Fields step
+    const columns = [
+      { index: 0, name: 'Treatment', originalName: 'Condition', uniqueValues: ['Ctrl', 'Treat'], cardinality: 2 },
+      { index: 1, name: 'Organ', originalName: 'Tissue', uniqueValues: ['Liver', 'Brain'], cardinality: 2 },
+    ]
+    const result = computeGroupsFromCsv(csvData, columns, new Set([0]))
+    expect(result.groups).toHaveLength(2)
+    expect(result.groups.find(g => g.name === 'Ctrl')?.samples).toEqual(['S1'])
+    expect(result.groups.find(g => g.name === 'Treat')?.samples).toEqual(['S2'])
+
+    // Metadata should use the display name as key
+    expect(result.metadata[0].fields['Treatment']).toBe('Ctrl')
+    expect(result.metadata[0].fields['Organ']).toBe('Liver')
+  })
+
+  it('should handle the real-world TSV format from the bug report', () => {
+    const text = [
+      'File Name\tTreatment Group',
+      'exp275_260401_YS_RNA_blank_001\tBlank',
+      'exp275_260401_YS_RNA_SplusA1_002\tS+A',
+      'exp275_260401_YS_RNA_A2_004\tA',
+      'exp275_260401_YS_RNA_NC_005\tDigControl',
+      'exp275_260401_YS_RNA_R2_007\tR',
+      'exp275_260401_YS_RNA_S2_009\tS',
+      'exp275_260401_YS_RNA_C1_010\tC',
+      'exp275_260401_YS_RNA_RplusA1_011\tR+A',
+    ].join('\n')
+    const csvData = parseCSV(text)
+
+    expect(csvData.sampleColumn).toBe('File Name')
+    expect(csvData.columns).toEqual(['File Name', 'Treatment Group'])
+    expect(csvData.rows).toHaveLength(8)
+
+    const columns = [
+      { index: 0, name: 'Treatment Group', uniqueValues: ['Blank', 'S+A', 'A', 'DigControl', 'R', 'S', 'C', 'R+A'], cardinality: 8 },
+    ]
+    const result = computeGroupsFromCsv(csvData, columns, new Set([0]))
+    expect(result.groups).toHaveLength(8)
+
+    const blankGroup = result.groups.find(g => g.name === 'Blank')
+    expect(blankGroup?.samples).toEqual(['exp275_260401_YS_RNA_blank_001'])
+
+    const saGroup = result.groups.find(g => g.name === 'S+A')
+    expect(saGroup?.samples).toEqual(['exp275_260401_YS_RNA_SplusA1_002'])
+  })
+})
+
+describe('integration: mixed experimental + QC + test samples', () => {
+  // Simulates the real dataset pattern:
+  // 154 experimental (11 fields), ~15 QC (6-7 fields), 3 test (4 fields)
+  const experimental = [
+    'LT_13102025_212_WT_Glu_3_20_S_091123_T1_33',
+    'LT_13102025_213_WT_Glu_3_20_S_091123_T1_34',
+    'LT_13102025_214_KI_Glu_3_20_S_091123_T1_35',
+    'LT_13102025_215_KI_Glu_6_40_L_091123_T1_36',
+    'LT_13102025_216_WT_Glu_6_40_L_091123_T1_37',
+    'LT_13102025_217_WT_Glu_6_40_L_091123_T2_38',
+    'LT_13102025_218_KI_Glu_3_20_S_091123_T2_39',
+  ]
+  const qcSamples = [
+    'LT_13102025_EQC_Jurkat_1_2',
+    'LT_13102025_IQC_Pool_3',
+  ]
+  const testSamples = [
+    'test_EQC_Jurkat_02',
+  ]
+  const allLines = [...experimental, ...qcSamples, ...testSamples]
+
+  it('should detect dominantFieldCount=11 and flag QC/test as outliers', () => {
+    const analysis = analyzeDelimiter(allLines)
+    expect(analysis.delimiter).toBe('_')
+    expect(analysis.dominantFieldCount).toBe(11)
+
+    const outliers = detectOutliers(allLines, '_', analysis.dominantFieldCount)
+    // QC samples (6 fields) and test samples (4 fields) are outliers
+    expect(outliers).toHaveLength(qcSamples.length + testSamples.length)
+
+    // Experimental samples should NOT be flagged
+    const outlierIndices = new Set(outliers.map(o => o.index))
+    for (let i = 0; i < experimental.length; i++) {
+      expect(outlierIndices.has(i)).toBe(false)
+    }
+  })
+
+  it('should auto-classify QC/test outliers with smart defaults', () => {
+    const analysis = analyzeDelimiter(allLines)
+    const outliers = detectOutliers(allLines, '_', analysis.dominantFieldCount)
+
+    for (const outlier of outliers) {
+      outlier.action = classifyOutlierAction(outlier.sample, '_')
+    }
+
+    // All QC and test samples should be classified as 'qc'
+    expect(outliers.every(o => o.action === 'qc')).toBe(true)
+  })
+
+  it('should produce 11 columns from conforming samples', () => {
+    const analysis = analyzeDelimiter(allLines)
+    const outliers = detectOutliers(allLines, '_', analysis.dominantFieldCount)
+    const conforming = allLines.filter(
+      (_, i) => !outliers.some(o => o.index === i)
+    )
+
+    const conformingFieldCounts = conforming.map(s => s.split('_').length)
+    const effectiveMinFieldCount = Math.min(...conformingFieldCounts)
+
+    const columns = extractColumns(conforming, '_', effectiveMinFieldCount)
+    expect(columns).toHaveLength(11)
+  })
+
+  it('should auto-disable constant columns (cardinality 1)', () => {
+    const analysis = analyzeDelimiter(allLines)
+    const outliers = detectOutliers(allLines, '_', analysis.dominantFieldCount)
+    const conforming = allLines.filter(
+      (_, i) => !outliers.some(o => o.index === i)
+    )
+
+    const conformingFieldCounts = conforming.map(s => s.split('_').length)
+    const effectiveMinFieldCount = Math.min(...conformingFieldCounts)
+
+    const columns = extractColumns(conforming, '_', effectiveMinFieldCount)
+
+    // Auto-disable: only enable columns with cardinality > 1
+    const enabled = new Set(
+      columns.filter(f => f.cardinality > 1).map(f => f.index)
+    )
+
+    // Constant columns (LT, 13102025, Glu, 091123) should be disabled
+    const constantCols = columns.filter(c => c.cardinality === 1)
+    for (const col of constantCols) {
+      expect(enabled.has(col.index)).toBe(false)
+    }
+
+    // Variable columns should be enabled
+    const variableCols = columns.filter(c => c.cardinality > 1)
+    for (const col of variableCols) {
+      expect(enabled.has(col.index)).toBe(true)
+    }
+    expect(variableCols.length).toBeGreaterThan(0)
+  })
+})
+
+describe('extractSamplesFromDesignData', () => {
+  it('should extract samples with conditions into ParsedCsvData', () => {
+    const data = {
+      schema_version: '2.0',
+      samples: [
+        { sample_name: 'HeLa_DrugA_1', sample_type: 'sample', conditions: { 'Cell Line': 'HeLa', Treatment: 'Drug A' } },
+        { sample_name: 'HeLa_Ctrl_1', sample_type: 'sample', conditions: { 'Cell Line': 'HeLa', Treatment: 'Control' } },
+        { sample_name: 'MCF7_DrugA_1', sample_type: 'sample', conditions: { 'Cell Line': 'MCF7', Treatment: 'Drug A' } },
+      ],
+    }
+    const result = extractSamplesFromDesignData(data)
+    expect(result).not.toBeNull()
+    expect(result!.sampleColumn).toBe('sample_name')
+    expect(result!.columns).toEqual(['sample_name', 'Cell Line', 'Treatment'])
+    expect(result!.rows).toHaveLength(3)
+    expect(result!.rows[0]).toEqual({ sample_name: 'HeLa_DrugA_1', 'Cell Line': 'HeLa', Treatment: 'Drug A' })
+  })
+
+  it('should filter out QC and blank samples by sample_type', () => {
+    const data = {
+      samples: [
+        { sample_name: 'Sample_1', sample_type: 'sample', conditions: { Treatment: 'Drug A' } },
+        { sample_name: 'QC_Pool', sample_type: 'qc', conditions: { Treatment: 'QC' } },
+        { sample_name: 'Blank_1', sample_type: 'blank', conditions: {} },
+        { sample_name: 'Sample_2', sample_type: 'sample', conditions: { Treatment: 'Control' } },
+      ],
+    }
+    const result = extractSamplesFromDesignData(data)
+    expect(result).not.toBeNull()
+    expect(result!.rows).toHaveLength(2)
+    expect(result!.rows.map(r => r.sample_name)).toEqual(['Sample_1', 'Sample_2'])
+  })
+
+  it('should return null when no samples array exists', () => {
+    expect(extractSamplesFromDesignData({})).toBeNull()
+    expect(extractSamplesFromDesignData({ plates: [] })).toBeNull()
+  })
+
+  it('should return null when samples array is empty', () => {
+    expect(extractSamplesFromDesignData({ samples: [] })).toBeNull()
+  })
+
+  it('should return null when all samples are QC/blank', () => {
+    const data = {
+      samples: [
+        { sample_name: 'QC_1', sample_type: 'qc', conditions: { Treatment: 'QC' } },
+        { sample_name: 'Blank', sample_type: 'blank', conditions: {} },
+      ],
+    }
+    expect(extractSamplesFromDesignData(data)).toBeNull()
+  })
+
+  it('should return null when no samples have conditions', () => {
+    const data = {
+      samples: [
+        { sample_name: 'Sample_1', sample_type: 'sample', conditions: {} },
+        { sample_name: 'Sample_2', sample_type: 'sample' },
+      ],
+    }
+    expect(extractSamplesFromDesignData(data)).toBeNull()
+  })
+
+  it('should collect all condition keys across samples with mixed categories', () => {
+    const data = {
+      samples: [
+        { sample_name: 'S1', sample_type: 'sample', conditions: { 'Cell Line': 'HeLa', Treatment: 'Drug A' } },
+        { sample_name: 'S2', sample_type: 'sample', conditions: { 'Cell Line': 'MCF7', Timepoint: '24h' } },
+      ],
+    }
+    const result = extractSamplesFromDesignData(data)
+    expect(result).not.toBeNull()
+    expect(result!.columns).toEqual(['sample_name', 'Cell Line', 'Treatment', 'Timepoint'])
+    // S1 has no Timepoint → empty string
+    expect(result!.rows[0]).toEqual({ sample_name: 'S1', 'Cell Line': 'HeLa', Treatment: 'Drug A', Timepoint: '' })
+    // S2 has no Treatment → empty string
+    expect(result!.rows[1]).toEqual({ sample_name: 'S2', 'Cell Line': 'MCF7', Treatment: '', Timepoint: '24h' })
+  })
+
+  it('should preserve column insertion order from first occurrence', () => {
+    const data = {
+      samples: [
+        { sample_name: 'S1', sample_type: 'sample', conditions: { Timepoint: '24h', Treatment: 'Drug' } },
+        { sample_name: 'S2', sample_type: 'sample', conditions: { Treatment: 'Ctrl', 'Cell Line': 'HeLa' } },
+      ],
+    }
+    const result = extractSamplesFromDesignData(data)
+    // Timepoint seen first in S1, then Treatment, then Cell Line from S2
+    expect(result!.columns).toEqual(['sample_name', 'Timepoint', 'Treatment', 'Cell Line'])
+  })
+
+  it('should handle samples without sample_type (defaults to "sample")', () => {
+    const data = {
+      samples: [
+        { sample_name: 'S1', conditions: { Treatment: 'Drug A' } },
+        { sample_name: 'S2', conditions: { Treatment: 'Control' } },
+      ],
+    }
+    const result = extractSamplesFromDesignData(data)
+    expect(result).not.toBeNull()
+    expect(result!.rows).toHaveLength(2)
+  })
+
+  it('should handle case-insensitive sample_type filtering', () => {
+    const data = {
+      samples: [
+        { sample_name: 'S1', sample_type: 'SAMPLE', conditions: { Treatment: 'Drug' } },
+        { sample_name: 'QC1', sample_type: 'QC', conditions: { Treatment: 'QC' } },
+        { sample_name: 'B1', sample_type: 'Blank', conditions: {} },
+      ],
+    }
+    const result = extractSamplesFromDesignData(data)
+    expect(result).not.toBeNull()
+    expect(result!.rows).toHaveLength(1)
+    expect(result!.rows[0].sample_name).toBe('S1')
+  })
+
+  it('should work with a realistic MS Designer design_data structure', () => {
+    const data = {
+      schema_version: '2.0',
+      cell_line: 'HeLa',
+      scheduled_date: '2026-04-10',
+      extraction_trigger: 'manual',
+      plates: [{ name: 'Plate 1', layout_type: '96-well' }],
+      samples: [
+        { plate_id: 'Plate 1', well_id: 'A1', sample_name: 'HeLa_DrugA_24h_Rep1', sample_type: 'sample', conditions: { 'Cell Line': 'HeLa', Treatment: 'Drug A', Timepoint: '24h' } },
+        { plate_id: 'Plate 1', well_id: 'A2', sample_name: 'HeLa_DrugA_24h_Rep2', sample_type: 'sample', conditions: { 'Cell Line': 'HeLa', Treatment: 'Drug A', Timepoint: '24h' } },
+        { plate_id: 'Plate 1', well_id: 'A3', sample_name: 'HeLa_Ctrl_24h_Rep1', sample_type: 'sample', conditions: { 'Cell Line': 'HeLa', Treatment: 'Control', Timepoint: '24h' } },
+        { plate_id: 'Plate 1', well_id: 'B1', sample_name: 'EQC_Pool_1', sample_type: 'qc', conditions: {} },
+        { plate_id: 'Plate 1', well_id: 'B2', sample_name: 'Blank_1', sample_type: 'blank', conditions: {} },
+      ],
+      extraction_results: [],
+      sequence_params: { polarity: 'pos' },
+    }
+    const result = extractSamplesFromDesignData(data)
+    expect(result).not.toBeNull()
+    expect(result!.rows).toHaveLength(3) // Only experimental samples
+    expect(result!.columns).toEqual(['sample_name', 'Cell Line', 'Treatment', 'Timepoint'])
+
+    // Verify it's compatible with computeGroupsFromCsv
+    const columns = result!.columns
+      .filter(c => c !== 'sample_name')
+      .map((col, i) => ({
+        index: i,
+        name: col,
+        originalName: col,
+        uniqueValues: [...new Set(result!.rows.map(r => r[col]))],
+        cardinality: new Set(result!.rows.map(r => r[col])).size,
+      }))
+
+    // Group by Treatment only
+    const groups = computeGroupsFromCsv(result!, columns, new Set([1])) // Treatment is index 1
+    expect(groups.groups).toHaveLength(2)
+    expect(groups.groups.find(g => g.name === 'Drug A')?.samples).toHaveLength(2)
+    expect(groups.groups.find(g => g.name === 'Control')?.samples).toHaveLength(1)
+  })
+})
+
+describe('useAutoGroup auto-disable degenerate columns', () => {
+  it('auto-disables unique-per-row columns in paste mode', () => {
+    const auto = useAutoGroup()
+    auto.rawText.value = [
+      'Ctrl_WT_001',
+      'Ctrl_WT_002',
+      'Ctrl_WT_003',
+      'Treat_WT_004',
+      'Treat_WT_005',
+    ].join('\n')
+    auto.parseInput()
+
+    const lastCol = auto.fields.value.find(f => f.cardinality === 5)
+    expect(lastCol, 'expected a unique-per-row column').toBeTruthy()
+    expect(auto.enabledFields.value.has(lastCol!.index)).toBe(false)
+    // With the unique column auto-disabled, samples aggregate by Condition only
+    // (WT is constant, also auto-disabled): Ctrl=3 samples, Treat=2 samples.
+    expect(auto.groups.value).toHaveLength(2)
+    expect(auto.groups.value.every(g => g.samples.length > 1)).toBe(true)
+  })
+
+  it('auto-disables unique-per-row columns in CSV mode', () => {
+    const auto = useAutoGroup()
+    auto.inputMode.value = 'csv'
+    auto.csvData.value = parseCSV(
+      'sample,condition,uid\n' +
+      'S1,Ctrl,a1\n' +
+      'S2,Ctrl,a2\n' +
+      'S3,Treat,a3\n' +
+      'S4,Treat,a4\n',
+    )
+    auto.parseInput()
+
+    const uidField = auto.fields.value.find(f => f.name === 'uid')
+    expect(uidField, 'expected uid column').toBeTruthy()
+    expect(auto.enabledFields.value.has(uidField!.index)).toBe(false)
+  })
+
+  it('keeps useful columns (cardinality between 2 and N-1) enabled', () => {
+    const auto = useAutoGroup()
+    auto.rawText.value = [
+      'Ctrl_WT_Rep1',
+      'Ctrl_WT_Rep2',
+      'Ctrl_KO_Rep1',
+      'Treat_WT_Rep1',
+    ].join('\n')
+    auto.parseInput()
+
+    const goodCols = auto.fields.value.filter(
+      f => f.cardinality > 1 && f.cardinality < auto.samples.value.length,
+    )
+    for (const col of goodCols) {
+      expect(auto.enabledFields.value.has(col.index)).toBe(true)
+    }
+  })
+
+  it('exposes allSingletons=true when every group has exactly one sample', () => {
+    const auto = useAutoGroup()
+    auto.rawText.value = ['A_x_1', 'B_y_2', 'C_z_3'].join('\n')
+    auto.parseInput()
+    auto.enabledFields.value = new Set(auto.fields.value.map(f => f.index))
+
+    expect(auto.groups.value.length).toBe(3)
+    expect(auto.allSingletons.value).toBe(true)
+  })
+})