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

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

@@ -1,122 +0,0 @@
-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

@@ -1,278 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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'])
-  })
-})

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

@@ -1,70 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { composeTemplate } from '../../../composables/autoGroup/template'
-import type { ClassSchema, SampleClass } from '../../../types/auto-group'
-
-describe('composeTemplate', () => {
-  const samples = ['s_1', 's_2,with_comma', 's_3']
-  const classes: SampleClass[] = [
-    {
-      kind: 'biological',
-      subKind: 'Tissues',
-      label: 'Biological / Tissues',
-      members: [0, 1, 2],
-      classTagPositions: [],
-      disposition: 'group',
-    },
-  ]
-  const schema: ClassSchema = {
-    classKind: 'biological',
-    subKind: 'Tissues',
-    columns: [
-      { index: 0, name: 'Tissue', sourceIndices: [0], uniqueValues: ['Kidney', 'Liver'], cardinality: 2, role: 'factor' },
-    ],
-    groupBy: [0],
-  }
-
-  it('blank mode emits one row per sample with sample_name and header-only suggested columns', () => {
-    const { content } = composeTemplate(samples, null, null, { mode: 'blank', format: 'csv' })
-    const lines = content.split('\n')
-    expect(lines[0]).toBe('sample_name,group,class,replicate,notes')
-    expect(lines[1].startsWith('s_1,')).toBe(true)
-    expect(lines.length).toBe(samples.length + 1)
-  })
-
-  it('quotes values containing commas per RFC 4180', () => {
-    const { content } = composeTemplate(samples, null, null, { mode: 'blank', format: 'csv' })
-    expect(content).toContain('"s_2,with_comma"')
-  })
-
-  it('prefilled mode includes class label and schema columns', () => {
-    const tokenized = [['Kidney'], ['Kidney'], ['Liver']]
-    const { content } = composeTemplate(samples, [schema], classes, {
-      mode: 'prefilled',
-      format: 'csv',
-      tokenizedSamples: tokenized,
-    })
-    const lines = content.split('\n')
-    expect(lines[0]).toBe('sample_name,class,Tissue,group,notes')
-    expect(lines[1]).toContain('Biological / Tissues')
-    expect(lines[1]).toContain('Kidney')
-  })
-
-  it('TSV format uses tab separator and skips quoting commas', () => {
-    const { content } = composeTemplate(samples, null, null, { mode: 'blank', format: 'tsv' })
-    expect(content.split('\n')[2].split('\t')[0]).toBe('s_2,with_comma')
-  })
-
-  it('uses experiment code in filename when provided', () => {
-    const { filename } = composeTemplate(samples, null, null, {
-      mode: 'blank',
-      format: 'csv',
-      experimentCode: 'EXP-042',
-    })
-    expect(filename).toMatch(/^EXP-042_metadata_\d{4}-\d{2}-\d{2}\.csv$/)
-  })
-
-  it('falls back to default filename without experiment code', () => {
-    const { filename } = composeTemplate(samples, null, null, { mode: 'blank', format: 'csv' })
-    expect(filename).toMatch(/^sample_metadata_\d{4}-\d{2}-\d{2}\.csv$/)
-  })
-})