@morscherlab/mint-sdk 1.0.0-rc.2 → 1.0.0-rc.5

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

@@ -1,229 +1,9 @@
-import { describe, it, expect } from 'vitest'
+import { describe, it, expect, vi } 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', () => {
@@ -285,356 +65,6 @@ describe('parseCSV', () => {
   })
 })
 
-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 = {
@@ -648,12 +78,12 @@ describe('extractSamplesFromDesignData', () => {
     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!.columns).toEqual(['sample_name', 'Cell Line', 'Treatment', 'sample_type'])
     expect(result!.rows).toHaveLength(3)
-    expect(result!.rows[0]).toEqual({ sample_name: 'HeLa_DrugA_1', 'Cell Line': 'HeLa', Treatment: 'Drug A' })
+    expect(result!.rows[0]).toEqual({ sample_name: 'HeLa_DrugA_1', 'Cell Line': 'HeLa', Treatment: 'Drug A', sample_type: 'sample' })
   })
 
-  it('should filter out QC and blank samples by sample_type', () => {
+  it('should retain QC and blank samples and surface their type in sampleTypeHints', () => {
     const data = {
       samples: [
         { sample_name: 'Sample_1', sample_type: 'sample', conditions: { Treatment: 'Drug A' } },
@@ -664,8 +94,11 @@ describe('extractSamplesFromDesignData', () => {
     }
     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'])
+    // All 4 samples are retained — QC/blank are no longer filtered here.
+    expect(result!.rows).toHaveLength(4)
+    expect(result!.rows.map(r => r.sample_name)).toEqual(['Sample_1', 'QC_Pool', 'Blank_1', 'Sample_2'])
+    // sampleTypeHints parallels the rows array.
+    expect(result!.sampleTypeHints).toEqual(['sample', 'qc', 'blank', 'sample'])
   })
 
   it('should return null when no samples array exists', () => {
@@ -677,14 +110,18 @@ describe('extractSamplesFromDesignData', () => {
     expect(extractSamplesFromDesignData({ samples: [] })).toBeNull()
   })
 
-  it('should return null when all samples are QC/blank', () => {
+  it('should retain all-QC/blank batches and set sampleTypeHints accordingly', () => {
+    // QC_1 has conditions so allConditionKeys is non-empty; both samples are retained.
     const data = {
       samples: [
         { sample_name: 'QC_1', sample_type: 'qc', conditions: { Treatment: 'QC' } },
         { sample_name: 'Blank', sample_type: 'blank', conditions: {} },
       ],
     }
-    expect(extractSamplesFromDesignData(data)).toBeNull()
+    const result = extractSamplesFromDesignData(data)
+    expect(result).not.toBeNull()
+    expect(result!.rows).toHaveLength(2)
+    expect(result!.sampleTypeHints).toEqual(['qc', 'blank'])
   })
 
   it('should return null when no samples have conditions', () => {
@@ -706,11 +143,11 @@ describe('extractSamplesFromDesignData', () => {
     }
     const result = extractSamplesFromDesignData(data)
     expect(result).not.toBeNull()
-    expect(result!.columns).toEqual(['sample_name', 'Cell Line', 'Treatment', 'Timepoint'])
+    expect(result!.columns).toEqual(['sample_name', 'Cell Line', 'Treatment', 'Timepoint', 'sample_type'])
     // S1 has no Timepoint → empty string
-    expect(result!.rows[0]).toEqual({ sample_name: 'S1', 'Cell Line': 'HeLa', Treatment: 'Drug A', Timepoint: '' })
+    expect(result!.rows[0]).toEqual({ sample_name: 'S1', 'Cell Line': 'HeLa', Treatment: 'Drug A', Timepoint: '', sample_type: 'sample' })
     // S2 has no Treatment → empty string
-    expect(result!.rows[1]).toEqual({ sample_name: 'S2', 'Cell Line': 'MCF7', Treatment: '', Timepoint: '24h' })
+    expect(result!.rows[1]).toEqual({ sample_name: 'S2', 'Cell Line': 'MCF7', Treatment: '', Timepoint: '24h', sample_type: 'sample' })
   })
 
   it('should preserve column insertion order from first occurrence', () => {
@@ -721,8 +158,8 @@ describe('extractSamplesFromDesignData', () => {
       ],
     }
     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'])
+    // Timepoint seen first in S1, then Treatment, then Cell Line from S2; sample_type appended last.
+    expect(result!.columns).toEqual(['sample_name', 'Timepoint', 'Treatment', 'Cell Line', 'sample_type'])
   })
 
   it('should handle samples without sample_type (defaults to "sample")', () => {
@@ -737,7 +174,7 @@ describe('extractSamplesFromDesignData', () => {
     expect(result!.rows).toHaveLength(2)
   })
 
-  it('should handle case-insensitive sample_type filtering', () => {
+  it('should lower-case sample_type in sampleTypeHints regardless of input casing', () => {
     const data = {
       samples: [
         { sample_name: 'S1', sample_type: 'SAMPLE', conditions: { Treatment: 'Drug' } },
@@ -747,8 +184,9 @@ describe('extractSamplesFromDesignData', () => {
     }
     const result = extractSamplesFromDesignData(data)
     expect(result).not.toBeNull()
-    expect(result!.rows).toHaveLength(1)
-    expect(result!.rows[0].sample_name).toBe('S1')
+    // All 3 samples retained; hints are lower-cased.
+    expect(result!.rows).toHaveLength(3)
+    expect(result!.sampleTypeHints).toEqual(['sample', 'qc', 'blank'])
   })
 
   it('should work with a realistic MS Designer design_data structure', () => {
@@ -770,30 +208,20 @@ describe('extractSamplesFromDesignData', () => {
     }
     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)
+    // All 5 samples are retained (including QC and blank).
+    expect(result!.rows).toHaveLength(5)
+    expect(result!.columns).toEqual(['sample_name', 'Cell Line', 'Treatment', 'Timepoint', 'sample_type'])
+    expect(result!.sampleTypeHints).toEqual(['sample', 'sample', 'sample', 'qc', 'blank'])
   })
 })
 
 describe('useAutoGroup auto-disable degenerate columns', () => {
-  it('auto-disables unique-per-row columns in paste mode', () => {
+  it('collapses unique-per-row injection numbers via replicate pre-grouping', () => {
+    // The replicate pre-grouping pass strips the trailing 3-digit run-order
+    // tokens before tokenisation, so 5 inputs collapse to 2 base names
+    // (Ctrl_WT and Treat_WT). This supersedes the old "auto-disable
+    // unique-per-row column" mechanism — there IS no unique-per-row column
+    // for the schema to see, because pre-grouping already absorbed it.
     const auto = useAutoGroup()
     auto.rawText.value = [
       'Ctrl_WT_001',
@@ -804,30 +232,35 @@ describe('useAutoGroup auto-disable degenerate columns', () => {
     ].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)
+    // Ctrl has 3 samples, Treat has 2 — replicates expanded back from the
+    // base names by expandGroupsWithReplicates in the result computed.
+    const ctrl = auto.groups.value.find(g => g.name === 'Ctrl')
+    const treat = auto.groups.value.find(g => g.name === 'Treat')
+    expect(ctrl?.samples).toHaveLength(3)
+    expect(treat?.samples).toHaveLength(2)
     expect(auto.groups.value.every(g => g.samples.length > 1)).toBe(true)
   })
 
-  it('auto-disables unique-per-row columns in CSV mode', () => {
+  it('the schema never sees a degenerate unique-per-row column', () => {
+    // Same setup, asserting the contract from the other side: after the
+    // pre-grouping pass, the active schema's columns reflect the BASE
+    // tokens only. There's no column with cardinality === sample-count.
     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.rawText.value = [
+      'Ctrl_WT_001',
+      'Ctrl_WT_002',
+      'Ctrl_WT_003',
+      'Treat_WT_004',
+      'Treat_WT_005',
+    ].join('\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)
+    // 5 originals → 2 base names → 2 schema columns: condition (Ctrl/Treat)
+    // and the constant WT. Neither has cardinality 5.
+    const schema = auto.activeSchema.value
+    expect(schema).toBeTruthy()
+    expect(schema!.columns.every(c => c.cardinality < 5)).toBe(true)
   })
 
   it('keeps useful columns (cardinality between 2 and N-1) enabled', () => {
@@ -850,11 +283,82 @@ describe('useAutoGroup auto-disable degenerate columns', () => {
 
   it('exposes allSingletons=true when every group has exactly one sample', () => {
     const auto = useAutoGroup()
+    // All-unique samples: each is classified as unknown, all 3 columns are factor by default
     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))
-
+    // With all 3 factor columns in groupBy by default, each unique combination = singleton
     expect(auto.groups.value.length).toBe(3)
     expect(auto.allSingletons.value).toBe(true)
   })
 })
+
+describe('useAutoGroup — class-first orchestration', () => {
+  it('detects classes after parseInput runs', async () => {
+    const ag = useAutoGroup()
+    ag.rawText.value = [
+      'exp281_260415_SAM_SAH_Tissues_Kidney_M1_001',
+      'exp281_260415_SAM_SAH_Tissues_Liver_M1_002',
+      'exp281_260415_SAM_SAH_Tissues_IQC_003',
+    ].join('\n')
+    ag.parseInput()
+    const kinds = ag.classes.value.map(c => c.kind).sort()
+    expect(kinds).toContain('biological')
+    expect(kinds).toContain('iqc')
+  })
+
+  it('switches active schema when activeClassKey changes', () => {
+    const ag = useAutoGroup()
+    ag.rawText.value = [
+      'a_Kidney_M1_001',
+      'b_Liver_M1_002',
+      'c_IQC_003',
+    ].join('\n')
+    ag.parseInput()
+    const firstKey = ag.classes.value[0].subKind
+      ? `${ag.classes.value[0].kind}:${ag.classes.value[0].subKind}`
+      : ag.classes.value[0].kind
+    ag.activeClassKey.value = firstKey
+    expect(ag.activeSchema.value!.classKind).toBe(ag.classes.value[0].kind)
+  })
+
+  it('setClassDisposition rewrites disposition and re-derives qcGroups', () => {
+    const ag = useAutoGroup()
+    ag.rawText.value = [
+      'exp_Plasma_M1_001',
+      'exp_Plasma_M2_002',
+      'exp_IQC_003',
+    ].join('\n')
+    ag.parseInput()
+    ag.setClassDisposition('iqc', 'group')
+    expect(ag.classes.value.find(c => c.kind === 'iqc')!.disposition).toBe('group')
+  })
+
+  it('legacy setOutlierAction is a no-op deprecation shim', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const ag = useAutoGroup()
+    ag.rawText.value = ['a_b_c'].join('\n')
+    ag.parseInput()
+    ag.setOutlierAction(0, 'exclude')
+    expect(warn).toHaveBeenCalled()
+    warn.mockRestore()
+  })
+
+  it('preserves legacy public refs after redesign', () => {
+    const ag = useAutoGroup()
+    ag.rawText.value = 'a_b_c\nd_e_f'
+    ag.parseInput()
+    expect(ag.delimiter.value).toBeDefined()
+    expect(ag.fields.value).toBeDefined()
+    expect(ag.enabledFields.value).toBeDefined()
+    expect(ag.effectiveColumns.value).toBeDefined()
+    expect(ag.allSingletons.value).toBeDefined()
+  })
+
+  it('downloadTemplate composes blank template before classifier ran', () => {
+    const ag = useAutoGroup()
+    ag.rawText.value = 'a_b\nc_d'
+    ag.parseInput()
+    const { content } = ag.composeTemplateForTest({ mode: 'blank', format: 'csv' })
+    expect(content.split('\n')[0]).toContain('sample_name')
+  })
+})