@morscherlab/mint-sdk 1.2.0-beta.3 → 1.2.0-beta.5

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

@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest'
+import { findMerges } from '../../../composables/autoGroup/cooccurrence'
+import type { ClassSchema } from '../../../types/auto-group'
+
+const schema = (overrides: Partial<ClassSchema> = {}): ClassSchema => ({
+  classKind: 'biological',
+  columns: [
+    { index: 0, name: 'A', sourceIndices: [0], uniqueValues: ['SAM'], cardinality: 1, role: 'factor' },
+    { index: 1, name: 'B', sourceIndices: [1], uniqueValues: ['SAH'], cardinality: 1, role: 'factor' },
+  ],
+  groupBy: [],
+  ...overrides,
+})
+
+describe('findMerges', () => {
+  it('suggests merging SAM + SAH when both columns are factors and mutually paired', () => {
+    const s = schema({
+      columns: [
+        { index: 0, name: 'A', sourceIndices: [0], uniqueValues: ['SAM', 'WT'], cardinality: 2, role: 'factor' },
+        { index: 1, name: 'B', sourceIndices: [1], uniqueValues: ['SAH', 'CTL'], cardinality: 2, role: 'factor' },
+      ],
+    })
+    const rows = [
+      ['SAM', 'SAH'],
+      ['SAM', 'SAH'],
+      ['SAM', 'SAH'],
+      ['SAM', 'SAH'],
+      ['WT', 'CTL'],
+      ['WT', 'CTL'],
+      ['WT', 'CTL'],
+      ['WT', 'CTL'],
+    ]
+    const out = findMerges(s, rows)
+    expect(out.length).toBe(1)
+    expect(out[0].columnIndices).toEqual([0, 1])
+    expect(out[0].confidence).toBeGreaterThanOrEqual(0.95)
+  })
+
+  it('rejects merge between two adjacent constants (no factor among them)', () => {
+    const s = schema({
+      columns: [
+        { index: 0, name: 'A', sourceIndices: [0], uniqueValues: ['exp281'], cardinality: 1, role: 'constant' },
+        { index: 1, name: 'B', sourceIndices: [1], uniqueValues: ['260415'], cardinality: 1, role: 'constant' },
+      ],
+    })
+    const rows = Array.from({ length: 10 }, () => ['exp281', '260415'])
+    expect(findMerges(s, rows)).toEqual([])
+  })
+
+  it('rejects asymmetric pairing (forward functional but not backward)', () => {
+    const s = schema({
+      columns: [
+        { index: 0, name: 'A', sourceIndices: [0], uniqueValues: ['a', 'b'], cardinality: 2, role: 'factor' },
+        { index: 1, name: 'B', sourceIndices: [1], uniqueValues: ['x'], cardinality: 1, role: 'constant' },
+      ],
+    })
+    const rows = [
+      ['a', 'x'],
+      ['a', 'x'],
+      ['b', 'x'],
+      ['b', 'x'],
+    ]
+    expect(findMerges(s, rows)).toEqual([])
+  })
+
+  it('rejects suggestions when class size < 4', () => {
+    const s = schema({
+      columns: [
+        { index: 0, name: 'A', sourceIndices: [0], uniqueValues: ['a', 'b'], cardinality: 2, role: 'factor' },
+        { index: 1, name: 'B', sourceIndices: [1], uniqueValues: ['x', 'y'], cardinality: 2, role: 'factor' },
+      ],
+    })
+    const rows = [
+      ['a', 'x'],
+      ['b', 'y'],
+      ['a', 'x'],
+    ]
+    expect(findMerges(s, rows)).toEqual([])
+  })
+
+  it('rejects merge that would collapse two adjacent factors into a single constant', () => {
+    const s = schema({
+      columns: [
+        { index: 0, name: 'A', sourceIndices: [0], uniqueValues: ['x'], cardinality: 1, role: 'factor' },
+        { index: 1, name: 'B', sourceIndices: [1], uniqueValues: ['y'], cardinality: 1, role: 'factor' },
+      ],
+    })
+    const rows = Array.from({ length: 6 }, () => ['x', 'y'])
+    expect(findMerges(s, rows)).toEqual([])
+  })
+})

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

@@ -0,0 +1,122 @@
+import { describe, it, expect } from 'vitest'
+import { serializeFingerprint, restoreFingerprint } from '../../../composables/autoGroup/fingerprint'
+import type { ClassSchema } from '../../../types/auto-group'
+
+const schemas: ClassSchema[] = [
+  {
+    classKind: 'biological',
+    subKind: 'Tissues',
+    columns: [
+      {
+        index: 0,
+        name: 'Tissue',
+        sourceIndices: [0],
+        uniqueValues: ['Kidney', 'Liver'],
+        cardinality: 2,
+        role: 'factor',
+        ops: { alias: { Kidney: 'kidney_panel' } },
+      },
+    ],
+    groupBy: [0],
+  },
+]
+
+describe('fingerprint round-trip', () => {
+  it('serializes to a JSON-stringify-safe object (no Maps)', () => {
+    const fp = serializeFingerprint(schemas)
+    const stringified = JSON.stringify(fp)
+    const reparsed = JSON.parse(stringified)
+    expect(reparsed.version).toBe(1)
+    expect(reparsed.classes[0].columns[0].ops.alias.Kidney).toBe('kidney_panel')
+  })
+
+  it('round-trips through restore preserving group-by and ops', () => {
+    const fp = serializeFingerprint(schemas)
+    const restored = restoreFingerprint(fp, schemas)
+    expect(restored[0].groupBy).toEqual([0])
+    expect(restored[0].columns[0].ops?.alias?.Kidney).toBe('kidney_panel')
+  })
+
+  it('reports a clear error when current schema column count differs', () => {
+    const fp = serializeFingerprint(schemas)
+    const mismatched: ClassSchema[] = [
+      {
+        ...schemas[0],
+        columns: [], // empty
+      },
+    ]
+    expect(() => restoreFingerprint(fp, mismatched)).toThrow(/column count/i)
+  })
+
+  it('matches a pre-token-length snapshot to the schema with the same column count', () => {
+    // An OLD fingerprint (saved before token-length splitting) has no tokenLength.
+    const oldFp = {
+      version: 1 as const,
+      classes: [
+        {
+          kind: 'biological' as const,
+          subKind: 'Plasma',
+          columns: [
+            { name: 'A', role: 'factor' as const, sourceIndices: [0] },
+          ],
+          groupBy: [0],
+        },
+      ],
+    }
+    // Current data split into two Plasma schemas; the 2-column one is listed FIRST.
+    const current: ClassSchema[] = [
+      {
+        classKind: 'biological', subKind: 'Plasma', tokenLength: 5,
+        columns: [
+          { index: 0, name: 'A', sourceIndices: [0], uniqueValues: ['x'], cardinality: 1, role: 'factor' },
+          { index: 1, name: 'B', sourceIndices: [1], uniqueValues: ['y'], cardinality: 1, role: 'factor' },
+        ],
+        groupBy: [0, 1],
+      },
+      {
+        classKind: 'biological', subKind: 'Plasma', tokenLength: 4,
+        columns: [
+          { index: 0, name: 'A', sourceIndices: [0], uniqueValues: ['x'], cardinality: 1, role: 'factor' },
+        ],
+        groupBy: [0],
+      },
+    ]
+    // Must match the 1-column schema (same column count) rather than throwing on the 2-column first hit.
+    const restored = restoreFingerprint(oldFp, current)
+    expect(restored).toHaveLength(1)
+    expect(restored[0].columns).toHaveLength(1)
+  })
+
+  it('disambiguates schemas that share kind/subKind but differ in token length', () => {
+    const ragged: ClassSchema[] = [
+      {
+        classKind: 'biological',
+        subKind: 'Plasma',
+        tokenLength: 4,
+        columns: [
+          { index: 0, name: 'A', sourceIndices: [0], uniqueValues: ['x'], cardinality: 1, role: 'factor' },
+        ],
+        groupBy: [0],
+      },
+      {
+        classKind: 'biological',
+        subKind: 'Plasma',
+        tokenLength: 5,
+        columns: [
+          { index: 0, name: 'A', sourceIndices: [0], uniqueValues: ['x'], cardinality: 1, role: 'factor' },
+          { index: 1, name: 'B', sourceIndices: [1], uniqueValues: ['y'], cardinality: 1, role: 'factor' },
+        ],
+        groupBy: [0, 1],
+      },
+    ]
+    const fp = serializeFingerprint(ragged)
+    // Restore against the SAME schemas in reversed order: each snapshot must
+    // match its same-token-length schema, not collide on kind/subKind (which
+    // would mis-apply columns or throw on a column-count mismatch).
+    const restored = restoreFingerprint(fp, [ragged[1], ragged[0]])
+    const four = restored.find(s => s.tokenLength === 4)
+    const five = restored.find(s => s.tokenLength === 5)
+    expect(four?.columns).toHaveLength(1)
+    expect(five?.columns).toHaveLength(2)
+  })
+})

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

@@ -0,0 +1,278 @@
+import { describe, it, expect } from 'vitest'
+import { useAutoGroup, parseCSV } from '../../../composables/useAutoGroup'
+
+/**
+ * Layer-order behaviour of the auto-group engine: `groupBy` is an ORDERED list
+ * of hierarchy layers (first entry = the sample selector's major group), user
+ * toggles append at the end, and `moveGroupBy` reorders layers explicitly.
+ */
+
+function structuredEngine() {
+  const auto = useAutoGroup()
+  auto.inputMode.value = 'csv'
+  auto.csvData.value = parseCSV([
+    'Sample,Tissue,Timepoint,Dose',
+    'S1,Kidney,5min,High',
+    'S2,Kidney,10min,Low',
+    'S3,Liver,5min,High',
+  ].join('\n'))
+  auto.parseInput()
+  return auto
+}
+
+describe('useAutoGroup — groupBy layer order', () => {
+  it('should append a re-enabled column at the end of the layer order when toggled back on', () => {
+    const auto = structuredEngine()
+    const key = auto.activeClassKey.value
+    auto.toggleGroupBy(key, 0)
+    auto.toggleGroupBy(key, 0)
+    expect(auto.activeSchema.value?.groupBy).toEqual([1, 2, 0])
+  })
+
+  it('should compose group names following the toggle-defined layer order', () => {
+    const auto = structuredEngine()
+    const key = auto.activeClassKey.value
+    auto.toggleGroupBy(key, 0)
+    auto.toggleGroupBy(key, 0)
+    expect(auto.groups.value.map(g => g.name).sort()).toEqual([
+      '10min / Low / Kidney',
+      '5min / High / Kidney',
+      '5min / High / Liver',
+    ])
+  })
+
+  it('should move a layer toward the front when moveGroupBy direction is up', () => {
+    const auto = structuredEngine()
+    const key = auto.activeClassKey.value
+    auto.moveGroupBy(key, 1, 'up')
+    expect(auto.activeSchema.value?.groupBy).toEqual([1, 0, 2])
+  })
+
+  it('should compose group names following the moved layer order', () => {
+    const auto = structuredEngine()
+    const key = auto.activeClassKey.value
+    auto.moveGroupBy(key, 1, 'up')
+    expect(auto.groups.value.map(g => g.name).sort()).toEqual([
+      '10min / Kidney / Low',
+      '5min / Kidney / High',
+      '5min / Liver / High',
+    ])
+  })
+
+  it('should ignore moveGroupBy up when the layer is already first', () => {
+    const auto = structuredEngine()
+    const key = auto.activeClassKey.value
+    auto.moveGroupBy(key, 0, 'up')
+    expect(auto.activeSchema.value?.groupBy).toEqual([0, 1, 2])
+  })
+
+  it('should ignore moveGroupBy down when the layer is already last', () => {
+    const auto = structuredEngine()
+    const key = auto.activeClassKey.value
+    auto.moveGroupBy(key, 2, 'down')
+    expect(auto.activeSchema.value?.groupBy).toEqual([0, 1, 2])
+  })
+
+  it('should ignore moveGroupBy for a column that is not part of groupBy', () => {
+    const auto = structuredEngine()
+    const key = auto.activeClassKey.value
+    auto.toggleGroupBy(key, 1) // disable Timepoint
+    auto.moveGroupBy(key, 1, 'up')
+    expect(auto.activeSchema.value?.groupBy).toEqual([0, 2])
+  })
+})
+
+describe('useAutoGroup — field edits span every class exposing the field', () => {
+  /** Two tissue classes sharing a Timepoint × Dose schema. */
+  function twoClassEngine() {
+    const auto = useAutoGroup()
+    const names: string[] = []
+    for (const tissue of ['Liver', 'Kidney'])
+      for (const time of ['5min', '10min'])
+        for (const dose of ['High', 'Low'])
+          for (const rep of [1, 2, 3]) names.push(`${tissue}_${time}_${dose}_rep${rep}`)
+    auto.rawText.value = names.join('\n')
+    auto.parseInput()
+    return auto
+  }
+
+  function threeFactorClassEngine() {
+    const auto = useAutoGroup()
+    const names: string[] = []
+    for (const tissue of ['Liver', 'Kidney'])
+      for (const first of ['A', 'B'])
+        for (const second of ['C', 'D'])
+          for (const third of ['E', 'F'])
+            names.push(`${tissue}_${first}_${second}_${third}_rep1`)
+    auto.rawText.value = names.join('\n')
+    auto.parseInput()
+    return auto
+  }
+
+  it('should reorder the layer in every class when moving a field by name', () => {
+    const auto = twoClassEngine()
+    auto.moveGroupByField('Token 3', 'up')
+    expect(Object.values(auto.schemas.value).map(s => s.groupBy)).toEqual([[2, 1], [2, 1]])
+  })
+
+  it('should move a field from a non-active schema when the active schema has it disabled', () => {
+    const auto = twoClassEngine()
+    const activeKey = auto.activeClassKey.value
+    auto.toggleGroupBy(activeKey, 2)
+
+    auto.moveGroupByField('Token 3', 'up')
+
+    expect(Object.values(auto.schemas.value).map(schema => schema.groupBy)).toEqual([[1], [2, 1]])
+  })
+
+  it('should converge previously divergent class orders to the active schema order', () => {
+    const auto = threeFactorClassEngine()
+    const inactiveKey = Object.keys(auto.schemas.value).find(k => k !== auto.activeClassKey.value)!
+    auto.moveGroupBy(inactiveKey, 3, 'up')
+    auto.moveGroupBy(inactiveKey, 3, 'up')
+
+    auto.moveGroupByField('Token 4', 'up')
+
+    expect(Object.values(auto.schemas.value).map(schema => schema.groupBy)).toEqual([
+      [1, 3, 2],
+      [1, 3, 2],
+    ])
+  })
+
+  it('should keep class-only fields after shared fields in their existing order', () => {
+    const auto = threeFactorClassEngine()
+    const inactiveKey = Object.keys(auto.schemas.value).find(k => k !== auto.activeClassKey.value)!
+    const inactive = auto.schemas.value[inactiveKey]
+    auto.schemas.value = {
+      ...auto.schemas.value,
+      [inactiveKey]: {
+        ...inactive,
+        columns: [
+          ...inactive.columns,
+          {
+            index: 99,
+            name: 'Class-only',
+            sourceIndices: [],
+            uniqueValues: [],
+            cardinality: 0,
+            role: 'factor',
+          },
+        ],
+        groupBy: [3, 99, 1, 2],
+      },
+    }
+
+    auto.moveGroupByField('Token 4', 'up')
+
+    expect(auto.schemas.value[inactiveKey].groupBy).toEqual([1, 3, 2, 99])
+  })
+
+  it('should compose consistently ordered names across classes after a field move', () => {
+    const auto = twoClassEngine()
+    auto.moveGroupByField('Token 3', 'up')
+    expect(auto.groups.value.map(g => g.name).sort()).toEqual([
+      'Kidney / High / 10min',
+      'Kidney / High / 5min',
+      'Kidney / Low / 10min',
+      'Kidney / Low / 5min',
+      'Liver / High / 10min',
+      'Liver / High / 5min',
+      'Liver / Low / 10min',
+      'Liver / Low / 5min',
+    ])
+  })
+
+  it('should disable a field in every class when toggling it off by name', () => {
+    const auto = twoClassEngine()
+    auto.toggleGroupByField('Timepoint')
+    expect(Object.values(auto.schemas.value).map(s => s.groupBy)).toEqual([[2], [2]])
+  })
+
+  it('should disable a batch field when any class still has it enabled', () => {
+    const auto = twoClassEngine()
+    // Diverge the classes: disable Timepoint in the non-active class only.
+    const inactiveKey = Object.keys(auto.schemas.value).find(k => k !== auto.activeClassKey.value)!
+    auto.toggleGroupBy(inactiveKey, 1)
+    // The batch card reads ON while either class uses Timepoint.
+    auto.toggleGroupByField('Timepoint')
+    expect(Object.values(auto.schemas.value).every(s => !s.groupBy.includes(1))).toBe(true)
+  })
+
+  it('should append a re-enabled field as the last layer in every class', () => {
+    const auto = twoClassEngine()
+    auto.toggleGroupByField('Timepoint')
+    auto.toggleGroupByField('Timepoint')
+    expect(Object.values(auto.schemas.value).map(s => s.groupBy)).toEqual([[2, 1], [2, 1]])
+  })
+
+  it('should not enable a same-named constant column when re-enabling a batch field', () => {
+    const auto = twoClassEngine()
+    const activeKey = auto.activeClassKey.value
+    const active = auto.schemas.value[activeKey]
+    auto.schemas.value = {
+      ...auto.schemas.value,
+      [activeKey]: {
+        ...active,
+        columns: active.columns.map(column => column.index === 2 ? { ...column, role: 'constant' } : column),
+        groupBy: active.groupBy.filter(index => index !== 2),
+      },
+    }
+
+    auto.toggleGroupByField('Token 3')
+    auto.toggleGroupByField('Token 3')
+
+    expect(Object.values(auto.schemas.value).map(schema => schema.groupBy)).toEqual([[1], [1, 2]])
+  })
+
+  it('should ignore a field name that no class exposes', () => {
+    const auto = twoClassEngine()
+    auto.moveGroupByField('Nonexistent', 'up')
+    expect(Object.values(auto.schemas.value).map(s => s.groupBy)).toEqual([[1, 2], [1, 2]])
+  })
+})
+
+describe('useAutoGroup — class prefix only when disambiguation is needed', () => {
+  it('should not prefix group names when a single experimental class emits groups', () => {
+    const auto = useAutoGroup()
+    auto.rawText.value = [
+      'Liver_5min_High_rep1',
+      'Liver_5min_High_rep2',
+      'Liver_10min_Low_rep1',
+      'Liver_10min_Low_rep2',
+    ].join('\n')
+    auto.parseInput()
+    expect(auto.groups.value.map(g => g.name).sort()).toEqual([
+      '10min / Low',
+      '5min / High',
+    ])
+  })
+
+  it('should prefix each class with its short distinguishing label when several experimental classes emit groups', () => {
+    const auto = useAutoGroup()
+    auto.rawText.value = [
+      'Liver_5min_High_rep1',
+      'Liver_10min_Low_rep1',
+      'Kidney_5min_High_rep1',
+      'Kidney_10min_Low_rep1',
+    ].join('\n')
+    auto.parseInput()
+    expect(auto.groups.value.map(g => g.name).sort()).toEqual([
+      'Kidney / 10min / Low',
+      'Kidney / 5min / High',
+      'Liver / 10min / Low',
+      'Liver / 5min / High',
+    ])
+  })
+
+  it('should keep overlay QC groups unprefixed and unchanged', () => {
+    const auto = useAutoGroup()
+    auto.rawText.value = [
+      'Liver_5min_rep1',
+      'Liver_10min_rep1',
+      'IQC_001',
+      'IQC_002',
+    ].join('\n')
+    auto.parseInput()
+    expect(auto.qcGroups.value.map(g => g.name)).toEqual(['IQC'])
+  })
+})

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

@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest'
+import { composeGroups } from '../../../composables/autoGroup/compose'
+import type { ClassSchema, SampleClass } from '../../../types/auto-group'
+import type { TreeNode } from '../../../types'
+
+const tissues: ClassSchema = {
+  classKind: 'biological',
+  subKind: 'Tissues',
+  columns: [
+    { index: 0, name: 'Organ', sourceIndices: [0], uniqueValues: ['Kidney', 'Liver'], cardinality: 2, role: 'factor' },
+    { index: 1, name: 'Subject', sourceIndices: [1], uniqueValues: ['M1', 'M2'], cardinality: 2, role: 'factor' },
+    { index: 2, name: 'Injection #', sourceIndices: [2], uniqueValues: ['001', '002', '003'], cardinality: 3, role: 'run-order' },
+  ],
+  groupBy: [0, 1],
+}
+const tissuesClass: SampleClass = {
+  kind: 'biological',
+  subKind: 'Tissues',
+  label: 'Biological / Tissues',
+  members: [0, 1, 2],
+  classTagPositions: [],
+  disposition: 'group',
+}
+const input = {
+  tokenizedSamples: [
+    ['Kidney', 'M1', '001'],
+    ['Kidney', 'M2', '002'],
+    ['Liver', 'M1', '003'],
+  ],
+  sampleNames: ['k1', 'k2', 'l1'],
+  schemas: { 'biological:Tissues': tissues },
+  classes: [tissuesClass],
+}
+
+function child(node: TreeNode | undefined, label: string): TreeNode | undefined {
+  return node?.children?.find(c => c.label === label)
+}
+
+describe('composeGroups groupTree (nested hierarchy)', () => {
+  it('nests class → layer1 → layer2 → sample leaves with sample-count badges', () => {
+    const tree = composeGroups(input).groupTree!
+    expect(tree).toHaveLength(1)
+    const root = tree[0]
+    expect(root.label).toBe('Biological / Tissues')
+    expect(root.badge).toBe(3) // total samples under the class
+
+    const kidney = child(root, 'Kidney')
+    const liver = child(root, 'Liver')
+    expect(kidney?.badge).toBe(2)
+    expect(liver?.badge).toBe(1)
+
+    const kidneyM1 = child(kidney, 'M1')
+    const kidneyM2 = child(kidney, 'M2')
+    expect(kidneyM1?.badge).toBe(1)
+    expect(kidneyM2?.badge).toBe(1)
+
+    // Leaf = the actual sample; injection number carried as leaf metadata + badge.
+    const leaf = kidneyM1?.children?.[0]
+    expect(leaf?.label).toBe('k1')
+    expect(leaf?.children).toBeUndefined()
+    expect(leaf?.metadata?.injection).toBe('001')
+    expect(leaf?.badge).toBe('001')
+  })
+
+  it('gives every node a stable unique id derived from its path', () => {
+    const tree = composeGroups(input).groupTree!
+    const ids = new Set<string>()
+    const walk = (n: TreeNode) => { ids.add(n.id); n.children?.forEach(walk) }
+    tree.forEach(walk)
+    // class + Kidney + Liver + M1(×2 paths) + M2 + 3 leaves = 9 distinct ids
+    expect(ids.size).toBe(9)
+  })
+
+  it('puts samples directly under the class node when no columns are grouped', () => {
+    const flatSchema: ClassSchema = { ...tissues, groupBy: [] }
+    const tree = composeGroups({ ...input, schemas: { 'biological:Tissues': flatSchema } }).groupTree!
+    const root = tree[0]
+    expect(root.badge).toBe(3)
+    expect(root.children?.map(c => c.label)).toEqual(['k1', 'k2', 'l1'])
+  })
+
+  it('excludes overlay/QC classes from the experimental groupTree', () => {
+    const iqcSchema: ClassSchema = {
+      classKind: 'iqc',
+      columns: [{ index: 0, name: 'IQC', sourceIndices: [0], uniqueValues: ['IQC'], cardinality: 1, role: 'class-tag' }],
+      groupBy: [],
+    }
+    const iqcClass: SampleClass = {
+      kind: 'iqc', label: 'IQC', members: [3], classTagPositions: [0], disposition: 'overlay',
+    }
+    const tree = composeGroups({
+      tokenizedSamples: [...input.tokenizedSamples, ['IQC']],
+      sampleNames: [...input.sampleNames, 'qc1'],
+      schemas: { 'biological:Tissues': tissues, iqc: iqcSchema },
+      classes: [tissuesClass, iqcClass],
+    }).groupTree!
+    expect(tree.map(n => n.label)).toEqual(['Biological / Tissues'])
+  })
+})

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

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import {
+  pickPrimaryDelimiter,
+  splitMulti,
+  detectClass,
+  buildClassSchema,
+  composeGroups,
+} from '../../../composables/autoGroup'
+
+const FIXTURE = resolve(__dirname, '../../fixtures/auto-group/mixed-lc-ms-batch.txt')
+
+describe('mixed LC-MS batch integration', () => {
+  const samples = readFileSync(FIXTURE, 'utf-8').trim().split('\n')
+  const delim = pickPrimaryDelimiter(samples)
+  const tokenized = samples.map(s => splitMulti(s, delim))
+  const classes = detectClass(tokenized, {})
+
+  it('detects exactly 81 Biological/Tissues samples', () => {
+    const c = classes.find(c => c.kind === 'biological' && c.subKind === 'Tissues')
+    expect(c?.members.length).toBe(81)
+  })
+
+  it('detects exactly 81 Biological/Plasma samples', () => {
+    const c = classes.find(c => c.kind === 'biological' && c.subKind === 'Plasma')
+    expect(c?.members.length).toBe(81)
+  })
+
+  it('detects exactly 3 IQC and 3 EQC samples', () => {
+    const iqc = classes.find(c => c.kind === 'iqc')
+    const eqc = classes.find(c => c.kind === 'eqc')
+    expect(iqc?.members.length).toBe(3)
+    expect(eqc?.members.length).toBe(3)
+  })
+
+  it('totals biological + QC overlay + excluded === 187', () => {
+    const tissues = classes.find(c => c.kind === 'biological' && c.subKind === 'Tissues')
+    const plasma = classes.find(c => c.kind === 'biological' && c.subKind === 'Plasma')
+    const overlayKinds = ['iqc', 'eqc', 'standard', 'spike-in', 'stock', 'blank']
+    const overlayCount = classes
+      .filter(c => overlayKinds.includes(c.kind))
+      .reduce((acc, c) => acc + c.members.length, 0)
+    const unknownCount = classes
+      .filter(c => c.kind === 'unknown')
+      .reduce((acc, c) => acc + c.members.length, 0)
+    expect((tissues?.members.length ?? 0) + (plasma?.members.length ?? 0) + overlayCount + unknownCount).toBe(187)
+  })
+
+  it('default workspace produces 3 Kidney/Liver/Tumor groups of 27 each', () => {
+    const tissuesClass = classes.find(c => c.kind === 'biological' && c.subKind === 'Tissues')!
+    const tissuesTokens = tissuesClass.members.map(i => tokenized[i])
+    const schema = buildClassSchema(
+      tissuesTokens,
+      'biological',
+      'Tissues',
+      tissuesClass.classTagPositions,
+    )
+    // The Tissue column should be a factor with 3 unique values.
+    const tissueCol = schema.columns.find(c => c.uniqueValues.length === 3 && c.role === 'factor')
+    expect(tissueCol).toBeDefined()
+    const result = composeGroups({
+      tokenizedSamples: tokenized,
+      sampleNames: samples,
+      schemas: { 'biological:Tissues': { ...schema, groupBy: [tissueCol!.index] } },
+      classes: [tissuesClass],
+    })
+    expect(result.experimentalGroups!.length).toBe(3)
+    expect(result.experimentalGroups!.every(g => g.samples.length === 27)).toBe(true)
+    const names = result.experimentalGroups!.map(g => g.name).sort()
+    // Only the Tissues class is passed here, so no disambiguating class prefix
+    // is applied: the organ factor is the first (major) hierarchy layer.
+    expect(names).toEqual(['Kidney', 'Liver', 'Tumor'])
+  })
+})