@morscherlab/mint-sdk 1.3.0 → 1.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morscherlab/mint-sdk",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "MINT Platform SDK — Vue 3 components, composables, and types for plugin development. MINT = Mass-spec INtegrated Toolkit.",
   "type": "module",
   "main": "./dist/index.js",
@@ -85,7 +85,7 @@
   },
   "devDependencies": {
     "@histoire/plugin-vue": "1.0.0-beta.1",
-    "@types/node": "22.20.4",
+    "@types/node": "26.6.3",
     "@vitejs/plugin-vue": "6.0.9",
     "@vue/language-core": "3.3.11",
     "@vue/test-utils": "2.5.1",

package/src/__tests__/components/AutoGroupModal.anatomy.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'vitest'
+import {
+  engineAnatomy,
+  engineQcChips,
+  engineSchemasToCards,
+  experimentLabel,
+  previewValues,
+} from '../../components/AutoGroupModal.adapter'
+import { useAutoGroup } from '../../composables/useAutoGroup'
+
+const tracingBatch = [
+  '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', 'LT_13102025_219_KI_Glu_6_40_L_091123_T2_40',
+  'LT_13102025_EQC_Jurkat_1_2', 'LT_13102025_EQC_Jurkat_2_8', 'LT_13102025_IQC_Pool_1_5',
+]
+
+function anatomyOf(samples: string[]) {
+  const engine = useAutoGroup()
+  engine.rawText.value = samples.join('\n')
+  engine.parseInput()
+  const cards = engineSchemasToCards(engine.schemas.value, engine.activeClassKey.value)
+  return { engine, anatomy: engineAnatomy(engine.classes.value, engine.schemas.value, engine.tokenized.value, cards) }
+}
+
+describe('previewValues', () => {
+  it('should list all values when there are three or fewer', () => {
+    expect(previewValues(['a', 'b', 'c'])).toBe('a, b, c')
+  })
+
+  it('should list three values and the rest as a count when there are more', () => {
+    expect(previewValues(['212', '213', '214', '215', '216'])).toBe('212, 213, 214 … +2')
+  })
+})
+
+describe('engineAnatomy', () => {
+  it('should show the tokens of one study sample in name order when the batch is parsed', () => {
+    expect(anatomyOf(tracingBatch).anatomy.map(token => token.text)).toEqual(
+      ['212', 'WT', 'Glu', '3', '20', 'S', '091123', 'T1', '33'],
+    )
+  })
+
+  it('should mark a grouped field with its layer when the field is on', () => {
+    expect(anatomyOf(tracingBatch).anatomy[1]).toEqual({ text: 'WT', caption: '1', state: 'on' })
+  })
+
+  it('should mark a field that is off by default with its name when the field is a sample ID', () => {
+    expect(anatomyOf(tracingBatch).anatomy[0]).toEqual({ text: '212', caption: 'Sample ID', state: 'off' })
+  })
+
+  it('should mark a constant token as fixed when it is not a grouping field', () => {
+    expect(anatomyOf(tracingBatch).anatomy[2]).toEqual({ text: 'Glu', caption: 'constant', state: 'fixed' })
+  })
+
+  it('should return no tokens when the batch has no study sample', () => {
+    expect(anatomyOf(['QC_01', 'QC_02']).anatomy).toEqual([])
+  })
+})
+
+describe('engineQcChips', () => {
+  it('should list each QC class with its sample count when the batch has QC samples', () => {
+    expect(engineQcChips(anatomyOf(tracingBatch).engine.classes.value)).toEqual([
+      { name: 'EQC', count: 2 },
+      { name: 'IQC', count: 1 },
+    ])
+  })
+})
+
+describe('experimentLabel', () => {
+  it('should join the header fields when the batch has them', () => {
+    expect(experimentLabel({ code: 'exp157', date: '2025-10-13', operator: 'LT' })).toBe('exp157 · 2025-10-13 · LT')
+  })
+
+  it('should return an empty label when the batch has no header', () => {
+    expect(experimentLabel({})).toBe('')
+  })
+})
+
+describe('engineSchemasToCards value preview', () => {
+  it('should shorten the value list of a card when the field has more than three values', () => {
+    const { engine } = anatomyOf(tracingBatch)
+    const cards = engineSchemasToCards(engine.schemas.value, engine.activeClassKey.value)
+    expect(cards.fields.find(field => field.key === 'Sample ID')?.vals).toBe('212, 213, 214 … +5')
+  })
+})

package/src/__tests__/components/AutoGroupModal.wiring.test.ts

@@ -0,0 +1,53 @@
+import { mount } from '@vue/test-utils'
+import { createPinia } from 'pinia'
+import { describe, expect, it } from 'vitest'
+import { nextTick } from 'vue'
+import AutoGroupModal from '../../components/AutoGroupModal.vue'
+import SmartGroupFieldRecipe from '../../components/SmartGroupFieldRecipe.vue'
+
+const replicated = ['WT', 'KO'].flatMap(genotype =>
+  ['Vehicle', 'Drug'].flatMap(treatment => ['1', '2', '3'].map(rep => `exp031_250318_SU_${genotype}_${treatment}_${rep}`)),
+)
+// One sample for each animal and time point: no replicate in the name.
+const unreplicated = ['m1', 'm2', 'm3'].flatMap(animal => ['0min', '20min'].map(time => `${animal}_${time}`))
+
+function recipeFor(samples: string[]) {
+  const wrapper = mount(AutoGroupModal, {
+    props: { modelValue: true, samples },
+    global: { plugins: [createPinia()], stubs: { Teleport: true } },
+  })
+  return wrapper.findComponent(SmartGroupFieldRecipe)
+}
+
+describe('AutoGroupModal field recipe wiring', () => {
+  it('should pass the tokens of an example name when samples are pasted', () => {
+    const anatomy = recipeFor(replicated).props('anatomy') as { text: string }[]
+    expect(anatomy.map(token => token.text)).toEqual(['WT', 'Vehicle', '1'])
+  })
+
+  it('should show the experiment header in the label when all names share it', () => {
+    expect(recipeFor(replicated).props('experimentLabel')).toBe('exp031 · 2025-03-18 · SU')
+  })
+
+  it('should rename the field when the recipe emits rename', async () => {
+    const recipe = recipeFor(replicated)
+    recipe.vm.$emit('rename', 0, 'Genotype')
+    await nextTick()
+    expect((recipe.props('fields') as { key: string }[])[0].key).toBe('Genotype')
+  })
+
+  it('should give no hints when the groups have replicates', () => {
+    expect((recipeFor(replicated).props('hints') as (string | null)[]).every(hint => hint === null)).toBe(true)
+  })
+
+  it('should hint how many groups remain for each field when every group has one sample', () => {
+    expect(recipeFor(unreplicated).props('hints')).toEqual(['off → 2 groups', 'off → 3 groups'])
+  })
+})
+
+describe('AutoGroupModal reserved names', () => {
+  it('should reserve the name of a column that is not a field when samples are pasted', () => {
+    const recipe = recipeFor(['Liver_A_rep1', 'Liver_A_rep2', 'Liver_B_rep1', 'Liver_B_rep2'])
+    expect(recipe.props('reservedNames')).toContain('Matrix')
+  })
+})

package/src/__tests__/components/PlateEditor.test.ts

@@ -359,6 +359,16 @@ describe('PlateEditor — wells', () => {
     expect(plate(wrapper).props('selectionMode')).toBe('drag')
   })
 
+  it('should show the hint prop in the footer until drag mode replaces it', async () => {
+    const wrapper = mountEditor({ wellDrag: true, hint: 'Drop samples here' })
+
+    expect(wrapper.get('.mint-plate-editor__hint').text()).toBe('Drop samples here')
+
+    await wrapper.get('[data-action="drag"]').trigger('click')
+
+    expect(wrapper.get('.mint-plate-editor__hint').text()).not.toBe('Drop samples here')
+  })
+
   it('should emit well-move with the active rack id', () => {
     const wrapper = mountEditor({ wellDrag: true })
 

package/src/__tests__/components/SampleSelector.test.ts

@@ -277,7 +277,11 @@ describe('AutoGroupModal multi-schema auto workflow', () => {
       },
     })
 
-    await wrapper.find('.sg-switch').trigger('click')
+    // Switch the sample-ID field of the first class on, then the only field of
+    // the second class off: one class still has a grouping field.
+    await wrapper.find('[data-test="field-off"] [role="switch"]').trigger('click')
+    const otherField = wrapper.findAll('[data-test="field-on"]').find(row => !row.text().includes('Sample ID'))
+    await otherField!.find('[role="switch"]').trigger('click')
 
     expect(wrapper.find('.sg-foot .mint-button--primary').attributes('disabled')).toBeUndefined()
   })
@@ -400,30 +404,24 @@ describe('AutoGroupModal CSV upload', () => {
 })
 
 describe('SmartGroupFieldRecipe CSV menu', () => {
-  it('emits download-template from its menu item', async () => {
+  const menuOf = (wrapper: ReturnType<typeof mount>) => wrapper.findComponent({ name: 'ActionMenu' })
+
+  it('should emit download-template when the user picks that menu item', () => {
     const wrapper = mount(SmartGroupFieldRecipe)
-    await wrapper.find('.fr-upload').trigger('click')
-    const items = wrapper.findAll('.fr-csv-item')
-    expect(items).toHaveLength(3)
-    await items[1].trigger('click')
+    menuOf(wrapper).vm.$emit('select', { id: 'template', label: 'Download template' })
     expect(wrapper.emitted('download-template')).toHaveLength(1)
   })
 
-  it('emits download-prefilled from its menu item', async () => {
+  it('should emit download-prefilled when the user picks that menu item', () => {
     const wrapper = mount(SmartGroupFieldRecipe)
-    await wrapper.find('.fr-upload').trigger('click')
-    await wrapper.findAll('.fr-csv-item')[2].trigger('click')
+    menuOf(wrapper).vm.$emit('select', { id: 'prefilled', label: 'Download pre-filled' })
     expect(wrapper.emitted('download-prefilled')).toHaveLength(1)
   })
 
-  it('disables the download items (and emits nothing) when canDownloadTemplate is false', async () => {
+  it('should disable the two download items when canDownloadTemplate is false', () => {
     const wrapper = mount(SmartGroupFieldRecipe, { props: { canDownloadTemplate: false } })
-    await wrapper.find('.fr-upload').trigger('click')
-    const items = wrapper.findAll('.fr-csv-item')
-    expect(items[1].attributes('disabled')).toBeDefined()
-    expect(items[2].attributes('disabled')).toBeDefined()
-    await items[1].trigger('click')
-    expect(wrapper.emitted('download-template')).toBeUndefined()
+    const items = menuOf(wrapper).props('items') as Array<{ id: string; disabled?: boolean }>
+    expect(items.filter(item => item.disabled).map(item => item.id)).toEqual(['template', 'prefilled'])
   })
 })
 

package/src/__tests__/components/SmartGroupFieldRecipe.groups.test.ts

@@ -99,3 +99,26 @@ describe('fieldRecipeSummary', () => {
     ).toBe('info')
   })
 })
+
+describe('fieldRecipeSummary for groups of one', () => {
+  const group = (name: string, count: number) => ({ name, count, color: '#000' })
+
+  it('should report singletons when every group has one sample', () => {
+    const summary = fieldRecipeSummary({ activeFactors: ['A'], repOn: false, baseGroups: [group('a', 1), group('b', 1)] })
+    expect(summary.kind).toBe('singletons')
+  })
+})
+
+describe('fieldRecipeSummary for a batch with some replicates', () => {
+  const group = (name: string, count: number) => ({ name, count, color: '#000' })
+
+  it('should report singletons when half or more of the groups have one sample', () => {
+    const baseGroups = [group('a', 1), group('b', 1), group('c', 2)]
+    expect(fieldRecipeSummary({ activeFactors: ['A'], repOn: false, baseGroups }).kind).toBe('singletons')
+  })
+
+  it('should report info when fewer than half of the groups have one sample', () => {
+    const baseGroups = [group('a', 2), group('b', 2), group('c', 1)]
+    expect(fieldRecipeSummary({ activeFactors: ['A'], repOn: false, baseGroups }).kind).toBe('info')
+  })
+})

package/src/__tests__/components/SmartGroupFieldRecipe.test.ts

@@ -1,6 +1,30 @@
 import { mount } from '@vue/test-utils'
 import { describe, expect, it } from 'vitest'
 import SmartGroupFieldRecipe from '../../components/SmartGroupFieldRecipe.vue'
+import type { SmartGroupFieldRecipeProps } from '../../components/SmartGroup.types'
+
+const fields = [
+  { key: 'Sample ID', role: 'Sample ID', vals: '212, 213, 214 … +7', rep: true },
+  { key: 'Genotype', role: 'Factor', vals: 'WT, KI', rep: false },
+  { key: 'Dose', role: 'Factor', vals: '3, 6', rep: false },
+]
+
+function mountControlled(extra: Partial<SmartGroupFieldRecipeProps> = {}) {
+  return mount(SmartGroupFieldRecipe, {
+    props: {
+      fields,
+      enabled: [false, true, true],
+      layers: [null, 2, 1],
+      groups: [{ name: 'WT / 3', count: 3, color: '#3b82f6' }],
+      route: 'Overlay only',
+      headerCount: 15,
+      qcCount: 5,
+      experimentLabel: '',
+      ...extra,
+    },
+    attachTo: document.body,
+  })
+}
 
 describe('SmartGroupFieldRecipe', () => {
   it('should draw the QC chip dot as the neutral QC marker when a qcColor is set', () => {
@@ -9,4 +33,156 @@ describe('SmartGroupFieldRecipe', () => {
     const dot = wrapper.find('.sg-qc__chip .sg-dot').element as HTMLElement
     expect(dot.style.borderColor).toBe('var(--text-secondary-strong)')
   })
+
+  it('should list the grouped fields in layer order when layers are given', () => {
+    const names = mountControlled().findAll('[data-test="field-on"] .sg-field__name').map(node => node.text())
+    expect(names).toEqual(['Dose', 'Genotype'])
+  })
+
+  it('should list a field under "Left off" when it is not grouped by', () => {
+    const names = mountControlled().findAll('[data-test="field-off"] .sg-field__name').map(node => node.text())
+    expect(names).toEqual(['Sample ID'])
+  })
+
+  it('should emit toggle with the card index when the user switches a field', async () => {
+    const wrapper = mountControlled()
+    await wrapper.find('[data-test="field-off"] [role="switch"]').trigger('click')
+    expect(wrapper.emitted('toggle')).toEqual([[0]])
+  })
+
+  it('should emit move up when the user presses Alt+ArrowUp on the handle of the second layer', async () => {
+    const wrapper = mountControlled()
+    await wrapper.findAll('[data-test="field-on"] .fr-row__grip')[1].trigger('keydown', { key: 'ArrowUp', altKey: true })
+    expect(wrapper.emitted('move')).toEqual([[1, 'up']])
+  })
+
+  it('should emit rename with the new name when the user commits the name input', async () => {
+    const wrapper = mountControlled({ renamable: true })
+    await wrapper.find('[data-test="field-on"] .fr-row__rename').trigger('click')
+    const input = wrapper.find('[data-test="field-on"] input')
+    await input.setValue('Tracer dose')
+    await input.trigger('keydown', { key: 'Enter' })
+    expect(wrapper.emitted('rename')).toEqual([[2, 'Tracer dose']])
+  })
+
+  it('should show no rename control when the fields are not renamable', () => {
+    expect(mountControlled().find('.fr-row__rename').exists()).toBe(false)
+  })
+
+  it('should show the hint of a field when hints are given', () => {
+    const wrapper = mountControlled({ hints: [null, 'off → 2 groups', null] })
+    expect(wrapper.findAll('[data-test="field-on"]')[1].find('.fr-row__hint').text()).toBe('off → 2 groups')
+  })
+
+  it('should show the tokens of the example name when the anatomy is given', () => {
+    const wrapper = mountControlled({
+      anatomy: [
+        { text: '212', caption: 'Sample ID', state: 'off' },
+        { text: 'WT', caption: '2', state: 'on' },
+      ],
+    })
+    expect(wrapper.findAll('.fr-token__text').map(node => node.text())).toEqual(['212', 'WT'])
+  })
+
+  it('should show the empty state when there are no fields', () => {
+    const wrapper = mountControlled({ fields: [], enabled: [], layers: [], groups: [], headerCount: 0 })
+    expect(wrapper.find('[data-test="recipe-empty"]').exists()).toBe(true)
+  })
+
+  it('should show one chip for each QC class when qcChips are given', () => {
+    const wrapper = mountControlled({ qcChips: [{ name: 'EQC', count: 3 }, { name: 'Blank', count: 2 }] })
+    expect(wrapper.findAll('.sg-qc__chip').map(node => node.text())).toEqual(['EQC ×3', 'Blank ×2'])
+  })
+
+  it('should emit update:route when the user picks another QC routing', async () => {
+    const wrapper = mountControlled()
+    const exclude = wrapper.findAll('.sg-qc [role="radio"]').find(node => node.text() === 'Exclude')
+    await exclude!.trigger('click')
+    expect(wrapper.emitted('update:route')).toEqual([['Exclude']])
+  })
+
+  it('should warn that every group has one sample when the groups are all singletons', () => {
+    const wrapper = mountControlled({
+      groups: [{ name: 'a', count: 1, color: '#000' }, { name: 'b', count: 1, color: '#000' }],
+    })
+    expect(wrapper.find('.sg-summary--warn').text()).toContain('one sample')
+  })
+})
+
+describe('SmartGroupFieldRecipe keyboard and edge cases', () => {
+  const switchOf = (wrapper: ReturnType<typeof mount>, name: string) =>
+    wrapper.findAll('.fr-row').find(row => row.find('.sg-field__name').text() === name)!.find('[role="switch"]')
+
+  it('should keep focus on the switch of a field when the field moves to the other list', async () => {
+    const wrapper = mount(SmartGroupFieldRecipe, { attachTo: document.body })
+    await switchOf(wrapper, 'Dose').trigger('click')
+    await new Promise(resolve => setTimeout(resolve))
+    expect(document.activeElement).toBe(switchOf(wrapper, 'Dose').element)
+  })
+
+  it('should keep focus on the handle when a field moves up with the keyboard', async () => {
+    const wrapper = mount(SmartGroupFieldRecipe, { attachTo: document.body })
+    const grip = wrapper.findAll('[data-test="field-on"] .fr-row__grip')[1]
+    ;(grip.element as HTMLElement).focus()
+    await grip.trigger('keydown', { key: 'ArrowUp', altKey: true })
+    await new Promise(resolve => setTimeout(resolve))
+    expect(document.activeElement).toBe(wrapper.findAll('[data-test="field-on"] .fr-row__grip')[0].element)
+  })
+
+  it('should keep the name input open and emit nothing when another field has the new name', async () => {
+    const wrapper = mountControlled({ renamable: true })
+    await wrapper.find('[data-test="field-on"] .fr-row__rename').trigger('click')
+    const input = wrapper.find('[data-test="field-on"] input')
+    await input.setValue('Genotype')
+    await input.trigger('keydown', { key: 'Enter' })
+    expect([wrapper.emitted('rename'), wrapper.find('[data-test="field-on"] input').attributes('aria-invalid')]).toEqual([undefined, 'true'])
+  })
+
+  it('should not let the row be dragged when its name is being edited', async () => {
+    const wrapper = mountControlled({ renamable: true })
+    await wrapper.find('[data-test="field-on"] .fr-row__rename').trigger('click')
+    expect(wrapper.find('[data-test="field-on"]').attributes('draggable')).toBe('false')
+  })
+
+  it('should not show the empty state when the batch has samples but no field', () => {
+    const wrapper = mountControlled({ fields: [], enabled: [], layers: [], groups: [], headerCount: 2 })
+    expect(wrapper.find('[data-test="recipe-empty"]').exists()).toBe(false)
+  })
+
+  it('should move a field to "Left off" when layers are given but the toggles are not controlled', async () => {
+    const wrapper = mount(SmartGroupFieldRecipe, { props: { fields, layers: [null, 2, 1] }, attachTo: document.body })
+    await switchOf(wrapper, 'Dose').trigger('click')
+    const names = wrapper.findAll('[data-test="field-on"] .sg-field__name').map(node => node.text())
+    expect(names).toEqual(['Genotype'])
+  })
+})
+
+describe('SmartGroupFieldRecipe second review', () => {
+  const twoFields = [
+    { key: 'A', role: 'Factor', vals: 'a1, a2', rep: false },
+    { key: 'B', role: 'Factor', vals: 'b1, b2', rep: false },
+  ]
+  const onNames = (wrapper: ReturnType<typeof mount>) =>
+    wrapper.findAll('[data-test="field-on"] .sg-field__name').map(node => node.text())
+
+  it('should reorder the rows when the parent updates layers and the toggles are not controlled', async () => {
+    const wrapper = mount(SmartGroupFieldRecipe, { props: { fields: twoFields, layers: [1, 2] } })
+    await wrapper.setProps({ layers: [2, 1] })
+    expect(onNames(wrapper)).toEqual(['B', 'A'])
+  })
+
+  it('should emit move when layers are given and the toggles are not controlled', async () => {
+    const wrapper = mount(SmartGroupFieldRecipe, { props: { fields: twoFields, layers: [1, 2] } })
+    await wrapper.findAll('.fr-row__grip')[1].trigger('keydown', { key: 'ArrowUp', altKey: true })
+    expect(wrapper.emitted('move')).toEqual([[1, 'up']])
+  })
+
+  it('should keep the name input open when the new name is a reserved name', async () => {
+    const wrapper = mountControlled({ renamable: true, reservedNames: ['Matrix'] })
+    await wrapper.find('[data-test="field-on"] .fr-row__rename').trigger('click')
+    const input = wrapper.find('[data-test="field-on"] input')
+    await input.setValue('Matrix')
+    await input.trigger('keydown', { key: 'Enter' })
+    expect([wrapper.emitted('rename'), wrapper.find('[data-test="field-on"] input').attributes('aria-invalid')]).toEqual([undefined, 'true'])
+  })
 })

package/src/__tests__/composables/autoGroup/columns.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { inferRole, parseNumeric, buildClassSchema } from '../../../composables/autoGroup/columns'
+import { inferRole, parseNumeric, buildClassSchema, splitColumns } from '../../../composables/autoGroup/columns'
 
 describe('parseNumeric', () => {
   it('parses value+unit tokens', () => {
@@ -58,17 +58,36 @@ describe('inferRole', () => {
     expect(inferRole(make(['5nM', '10nM', '20nM']))).toBe('factor')
   })
 
-  it('returns replicate ONLY for explicit replicate-named tokens (rep1, Rep2, replicate3, R1)', () => {
-    // The replicate pre-grouping pass collapses real replicates by name
-    // before tokenisation, so the cardinality-based ID_PATTERN heuristic
-    // (M1, M2, …) was removed — those reach inferRole now only when they
-    // represent distinct conditions, and should be treated as factors.
+  it('should return id when each sample has its own numbered value', () => {
     expect(inferRole({
       values: ['M1', 'M2', 'M3', 'M4', 'M5'],
       position: 1,
       totalPositions: 3,
       classSize: 5,
-    })).toBe('factor')
+    })).toBe('id')
+  })
+
+  it('should return factor when a unique column is in a class of fewer than four samples', () => {
+    expect(inferRole({ values: ['M1', 'M2', 'M3'], position: 1, totalPositions: 3, classSize: 3 })).toBe('factor')
+  })
+
+  it('should return replicate when all values are T<n> tokens', () => {
+    expect(inferRole({ values: ['T1', 'T2', 'T1', 'T2'], position: 1, totalPositions: 3, classSize: 4 })).toBe('replicate')
+  })
+
+  it('should return factor when the values are B<n> label tokens', () => {
+    expect(inferRole({ values: ['B13', 'S13', 'B13', 'S13'], position: 1, totalPositions: 3, classSize: 4 })).toBe('factor')
+  })
+
+  it('should return replicate when a small counter repeats at the end of a name', () => {
+    expect(inferRole({ values: ['1', '2', '3', '1', '2', '3'], position: 2, totalPositions: 3, classSize: 6 })).toBe('replicate')
+  })
+
+  it('should return factor when a small number repeats in the middle of a name', () => {
+    expect(inferRole({ values: ['1', '2', '3', '1', '2', '3'], position: 1, totalPositions: 3, classSize: 6 })).toBe('factor')
+  })
+
+  it('should return replicate when all values are replicate-named tokens', () => {
     expect(inferRole({
       values: ['rep1', 'rep2', 'rep3'],
       position: 1,
@@ -87,12 +106,50 @@ describe('inferRole', () => {
     expect(inferRole(make(['Kidney', 'Liver', 'Tumor', 'Kidney', 'Liver']))).toBe('factor')
   })
 
-  it('returns ignore for very-high-cardinality opaque values', () => {
+  it('should return ignore when more than 50 values each repeat', () => {
     // Real-world LC-MS batches routinely have 30–50 distinct conditions, so the
-    // factor cap was raised to 50 (was 20). 80 unique values still reads as
-    // ignore — likely a sample-ID column rather than a meaningful factor.
+    // factor cap is 50. 80 values that each occur twice are not a sample ID
+    // and are too many for a factor.
+    const values = Array.from({ length: 160 }, (_, i) => `opaque-${i % 80}`)
+    expect(inferRole({ values, position: 0, totalPositions: 1, classSize: 160 })).toBe('ignore')
+  })
+
+  it('should return id when 80 opaque values are all unique', () => {
     const values = Array.from({ length: 80 }, (_, i) => `opaque-${i}`)
-    expect(inferRole({ values, position: 0, totalPositions: 1, classSize: 80 })).toBe('ignore')
+    expect(inferRole({ values, position: 0, totalPositions: 1, classSize: 80 })).toBe('id')
+  })
+})
+
+describe('splitColumns', () => {
+  it('should split on the hyphen when a column holds condition-replicate tokens', () => {
+    expect(splitColumns([['HMW', '1-1'], ['HMW', '1-2'], ['MMW', '2-1']]).rows[0]).toEqual(['HMW', '1', '1'])
+  })
+
+  it('should split stem and counter when two stems repeat', () => {
+    expect(splitColumns([['C1'], ['C2'], ['H1'], ['H2']]).rows[0]).toEqual(['C', '1'])
+  })
+
+  it('should keep a token whole when the column has one stem', () => {
+    expect(splitColumns([['D1'], ['D3'], ['D6'], ['D1']]).rows[0]).toEqual(['D1'])
+  })
+
+  it('should keep a token whole when each stem has one counter', () => {
+    expect(splitColumns([['B13'], ['S13'], ['B13'], ['S13']]).rows[0]).toEqual(['B13'])
+  })
+
+  it('should pad a name when it does not match the split of its column', () => {
+    const rows = [...Array.from({ length: 9 }, (_, i) => ['HMW', `${i + 1}-1`]), ['HMW', 'DigestControl']]
+    expect(splitColumns(rows).rows[9]).toEqual(['HMW', 'DigestControl', ''])
+  })
+
+  it('should report the source column of each new column when a column splits', () => {
+    expect(splitColumns([['HMW', '1-1'], ['MMW', '2-2']]).origin).toEqual([0, 1, 1])
+  })
+})
+
+describe('parseNumeric decimals', () => {
+  it('should read the value when the token has a decimal point', () => {
+    expect(parseNumeric('0.1uM')).toEqual({ value: 0.1, unit: 'uM', raw: '0.1uM' })
   })
 })
 
@@ -133,3 +190,35 @@ describe('buildClassSchema', () => {
     expect(schema.groupBy).toEqual(factorIndices)
   })
 })
+
+describe('column roles review regressions', () => {
+  const dose = (levels: string[]) =>
+    levels.flatMap((level, i) => [['Drug', level, `0${2 * i + 1}`], ['Drug', level, `0${2 * i + 2}`]])
+
+  it('should group by a bare-number dose when it sits before the injection number', () => {
+    expect(buildClassSchema(dose(['1', '5', '10']), 'unknown', undefined, []).groupBy).toEqual([1])
+  })
+
+  it('should leave a counter out of the group key when it sits before the injection number', () => {
+    expect(buildClassSchema(dose(['1', '2', '3']), 'unknown', undefined, []).groupBy).toEqual([])
+  })
+
+  it('should return factor when each sample has its own word with no digit', () => {
+    expect(inferRole({ values: ['Ctrl', 'DrugA', 'DrugB', 'DrugC'], position: 0, totalPositions: 2, classSize: 4 })).toBe('factor')
+  })
+
+  it('should return replicate when a zero-padded counter repeats at the end of a name', () => {
+    const values = ['01', '02', '03', '04', '01', '02', '03', '04']
+    expect(inferRole({ values, position: 2, totalPositions: 3, classSize: 8 })).toBe('replicate')
+  })
+
+  it('should return replicate when one counter of the run is missing', () => {
+    const values = ['1', '2', '4', '1', '2', '4']
+    expect(inferRole({ values, position: 2, totalPositions: 3, classSize: 6 })).toBe('replicate')
+  })
+
+  it('should return id when one value of a sample-number column has no digit', () => {
+    const values = [...Array.from({ length: 19 }, (_, i) => String(i + 11)), 'pool']
+    expect(inferRole({ values, position: 1, totalPositions: 3, classSize: 20 })).toBe('id')
+  })
+})