@morscherlab/mint-sdk 1.3.9 → 1.4.0-beta.1

package/src/__tests__/templates/templates.test.ts

@@ -1,1235 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  assertTemplateEnvelope,
-  bioTemplatePresetControlValuesToOptions,
-  createBioTemplatePackCollection,
-  createBioTemplatePresetCollection,
-  createBioTemplatePresetCollectionFromControls,
-  createAssayMatrixTemplate,
-  createCalibrationCurveTemplate,
-  createDoseResponseTemplate,
-  createElisaAssayCollection,
-  createFlowCytometryAssayCollection,
-  createFlowCytometryPanelTemplate,
-  createInstrumentRunTemplate,
-  createLcmsBatchCollection,
-  createPlateMapTemplate,
-  createProtocolStepsTemplate,
-  createQpcrExpressionCollection,
-  createQpcrPlateTemplate,
-  createReagentListTemplate,
-  createSampleSheetTemplate,
-  createSamplePrepTemplate,
-  createTargetedMetabolomicsCollection,
-  createDefaultBioTemplate,
-  createTemplateCollection,
-  createTimeCourseTemplate,
-  createWellPlateScreenCollection,
-  createWesternBlotAssayCollection,
-  ensureTemplateEnvelope,
-  ensureTemplateFromCollection,
-  extractTemplateCollection,
-  getBioTemplateComponentBindings,
-  getBioTemplateComponentProps,
-  getBioTemplateControlDefaults,
-  getBioTemplateControlSchema,
-  getBioTemplatePackInfo,
-  getBioTemplatePresetInfo,
-  getBioTemplateInfo,
-  listBioTemplateCatalog,
-  listBioTemplateComponentBindings,
-  listBioTemplateControlSchemas,
-  listBioTemplatePacks,
-  listBioTemplatePresets,
-  searchBioTemplatePacks,
-  searchBioTemplateCatalog,
-  searchBioTemplatePresets,
-  toBioTemplateComponentBindings,
-  toBioTemplateComponentBindingsById,
-  toBioTemplateComponentImports,
-  toBioTemplateComponentProps,
-  toBioTemplateComponentPropsByComponent,
-  toBioTemplateComponentPropsById,
-  toBioTemplateComponentSnippets,
-  toBioTemplateComponentUsage,
-  toAssayMatrixColumns,
-  toAssayMatrixDataFrame,
-  toAssayMatrixRows,
-  toAssayMatrixSampleOptions,
-  toCalibrationCurveDataFrame,
-  toCalibrationCurveRows,
-  toDoseConditions,
-  toDoseLayoutState,
-  toFlowPanelDataFrame,
-  toFlowPanelRows,
-  toInstrumentRunDataFrame,
-  toInstrumentRunRows,
-  toInstrumentRunScheduleEvents,
-  toInstrumentRunSteps,
-  racksFromPlateState,
-  toPlateMapEditorState,
-  toProtocolDataFrame,
-  toProtocolSteps,
-  toQpcrDataFrame,
-  toQpcrRows,
-  toQpcrWellPlateWells,
-  toReagentDataFrame,
-  toReagentListItems,
-  toSampleColumns,
-  toSampleDataFrame,
-  toSampleOptions,
-  toSamplePrepDataFrame,
-  toSamplePrepRows,
-  toSampleRows,
-  toTemplateDataFrame,
-  toTimeCourseDataFrame,
-  toTimeCourseRows,
-  toTimeCourseSteps,
-  toWellPlateWells,
-  TEMPLATE_COLLECTION_KEY,
-} from '../../templates'
-import bioTemplateCatalogContract from '../../../../bio-template-catalog.contract.json'
-import bioTemplatePacksContract from '../../../../bio-template-packs.contract.json'
-import bioTemplatePresetsContract from '../../../../bio-template-presets.contract.json'
-import type {
-  AssayMatrixTemplate,
-  DoseResponseTemplate,
-  FlowCytometryPanelTemplate,
-  InstrumentRunTemplate,
-  PlateMapTemplate,
-  ProtocolStepsTemplate,
-  QpcrPlateTemplate,
-  ReagentListTemplate,
-  SampleSheetTemplate,
-} from '../../templates'
-import doseResponseFixture from '../fixtures/templates/dose-response.json'
-import plateMapFixture from '../fixtures/templates/plate-map.json'
-import qpcrPlateFixture from '../fixtures/templates/qpcr-plate.json'
-import sampleSheetFixture from '../fixtures/templates/sample-sheet.json'
-
-describe('bio data templates', () => {
-  it('exposes a discoverable template catalog', () => {
-    const catalog = listBioTemplateCatalog()
-
-    expect(catalog.map(entry => entry.name)).toEqual([
-      'plate-map',
-      'sample-sheet',
-      'sample-prep',
-      'dose-response',
-      'calibration-curve',
-      'time-course',
-      'protocol-steps',
-      'assay-matrix',
-      'reagent-list',
-      'flow-cytometry-panel',
-      'instrument-run',
-      'qpcr-plate',
-    ])
-    expect(getBioTemplateInfo('wellplate')?.template_id).toBe('plate-map')
-    expect(getBioTemplateInfo('sample preparation')?.template_id).toBe('sample-prep')
-    expect(getBioTemplateInfo('dose design')?.template_id).toBe('dose-response')
-    expect(getBioTemplateInfo('dose-design')?.template_id).toBe('dose-response')
-    expect(getBioTemplateInfo('dose calculator')?.template_id).toBe('dose-response')
-    expect(getBioTemplateInfo('dose_calculator')?.template_id).toBe('dose-response')
-    expect(getBioTemplateInfo('protocol')?.template_id).toBe('protocol-steps')
-    expect(getBioTemplateInfo('standard curve')?.template_id).toBe('calibration-curve')
-    expect(getBioTemplateInfo('omics matrix')?.template_id).toBe('assay-matrix')
-    expect(getBioTemplateInfo('antibodies')?.template_id).toBe('reagent-list')
-    expect(getBioTemplateInfo('facs panel')?.template_id).toBe('flow-cytometry-panel')
-    expect(getBioTemplateInfo('run queue')?.template_id).toBe('instrument-run')
-    expect(getBioTemplateInfo('gene expression')?.template_id).toBe('qpcr-plate')
-    expect(searchBioTemplateCatalog('DoseCalculator')[0].name).toBe('dose-response')
-  })
-
-  it('matches the shared Python/frontend catalog contract', () => {
-    expect(listBioTemplateCatalog()).toEqual(bioTemplateCatalogContract)
-  })
-
-  it('exposes discoverable template collection packs', () => {
-    const packs = listBioTemplatePacks()
-
-    expect(packs.map(entry => entry.name)).toEqual([
-      'cell-culture-screen',
-      'omics-assay',
-      'longitudinal-study',
-      'molecular-assay',
-    ])
-    expect(getBioTemplatePackInfo('cell culture')?.templates).toEqual([
-      'sample-sheet',
-      'sample-prep',
-      'plate-map',
-      'reagent-list',
-      'protocol-steps',
-      'dose-response',
-      'flow-cytometry-panel',
-    ])
-    expect(getBioTemplatePackInfo('metabolomics')?.name).toBe('omics-assay')
-    expect(getBioTemplatePackInfo('metabolism')?.name).toBe('omics-assay')
-    expect(getBioTemplatePackInfo('metabolite profiling')?.name).toBe('omics-assay')
-    expect(getBioTemplatePackInfo('metabolomics')?.components).toContain('ExperimentTimeline')
-    expect(getBioTemplatePackInfo('longitudinal')?.add_command).toBe('mint add data-template-pack longitudinal-study --page')
-    expect(getBioTemplatePackInfo('gene expression')?.templates.at(-1)).toBe('qpcr-plate')
-    expect(getBioTemplatePackInfo('gene-expression')?.templates.at(-1)).toBe('qpcr-plate')
-    expect(searchBioTemplatePacks('WellPlate').map(entry => entry.name)).toEqual([
-      'cell-culture-screen',
-      'omics-assay',
-      'molecular-assay',
-    ])
-  })
-
-  it('matches the shared Python/frontend pack contract', () => {
-    expect(listBioTemplatePacks()).toEqual(bioTemplatePacksContract)
-  })
-
-  it('creates default template collections from curated packs', () => {
-    const plate = createDefaultBioTemplate('wellplate') as PlateMapTemplate
-    const pack = createBioTemplatePackCollection('cell culture')
-    const templates = extractTemplateCollection(pack)
-
-    expect(plate.template_id).toBe('plate-map')
-    expect(pack.metadata?.pack).toBe('cell-culture-screen')
-    expect(Object.keys(templates)).toEqual([
-      'sample-sheet',
-      'sample-prep',
-      'plate-map',
-      'reagent-list',
-      'protocol-steps',
-      'dose-response',
-      'flow-cytometry-panel',
-    ])
-    expect(toPlateMapEditorState(templates['plate-map'] as PlateMapTemplate).samples).toHaveLength(2)
-    expect(toDoseConditions(templates['dose-response'] as DoseResponseTemplate)[0].label).toBe('Compound A')
-    expect(getBioTemplateControlSchema('cell-culture-screen')?.sampleSheetSampleCount.default).toBe(2)
-    expect(getBioTemplateComponentBindings('cell-culture-screen').map(binding => binding.component)).toContain('DoseCalculator')
-    expect(() => createBioTemplatePackCollection('missing-pack')).toThrow("Unknown template pack 'missing-pack'.")
-  })
-
-  it('exposes discoverable template collection presets', () => {
-    const presets = listBioTemplatePresets()
-
-    expect(presets.map(entry => entry.name)).toEqual([
-      'wellplate-screen',
-      'qpcr-expression',
-      'lcms-batch',
-      'targeted-metabolomics',
-      'elisa-assay',
-      'flow-cytometry-assay',
-      'western-blot-assay',
-    ])
-    expect(getBioTemplatePresetInfo('wellplate')?.name).toBe('wellplate-screen')
-    expect(getBioTemplatePresetInfo('dose planner')?.name).toBe('wellplate-screen')
-    expect(getBioTemplatePresetInfo('dose-planner')?.name).toBe('wellplate-screen')
-    expect(getBioTemplatePresetInfo('gene expression')?.templates).toEqual([
-      'sample-sheet',
-      'qpcr-plate',
-    ])
-    expect(searchBioTemplatePresets('run queue')[0].name).toBe('lcms-batch')
-    expect(getBioTemplatePresetInfo('metabolomics')?.name).toBe('lcms-batch')
-    expect(getBioTemplatePresetInfo('metabolism')?.name).toBe('lcms-batch')
-    expect(getBioTemplatePresetInfo('metabolite profiling')?.name).toBe('lcms-batch')
-    expect(getBioTemplatePresetInfo('targeted metabolomics')?.name).toBe('targeted-metabolomics')
-    expect(searchBioTemplatePresets('internal standards')[0].name).toBe('targeted-metabolomics')
-    expect(getBioTemplatePresetInfo('immunoassay')?.templates).toEqual([
-      'plate-map',
-      'sample-sheet',
-      'calibration-curve',
-      'assay-matrix',
-    ])
-    expect(getBioTemplatePresetInfo('facs')?.templates).toEqual([
-      'sample-sheet',
-      'flow-cytometry-panel',
-      'assay-matrix',
-    ])
-    expect(getBioTemplatePresetInfo('immunoblot')?.templates).toEqual([
-      'sample-sheet',
-      'reagent-list',
-      'protocol-steps',
-      'assay-matrix',
-    ])
-  })
-
-  it('matches the shared Python/frontend preset contract', () => {
-    expect(listBioTemplatePresets()).toEqual(bioTemplatePresetsContract)
-  })
-
-  it('should not recommend AutoGroupModal when it is scheduled for removal', () => {
-    const components = listBioTemplateCatalog().flatMap(entry => entry.components)
-
-    expect(components).not.toContain('AutoGroupModal')
-  })
-
-  it('prefers generic dataframe adapters in catalog entries', () => {
-    const dataframeTemplates = listBioTemplateCatalog().filter(entry =>
-      entry.components.includes('DataFrame')
-    )
-
-    expect(dataframeTemplates.map(entry => entry.name)).toEqual([
-      'sample-sheet',
-      'sample-prep',
-      'calibration-curve',
-      'time-course',
-      'protocol-steps',
-      'assay-matrix',
-      'reagent-list',
-      'flow-cytometry-panel',
-      'instrument-run',
-      'qpcr-plate',
-    ])
-    for (const entry of dataframeTemplates) {
-      expect(entry.frontend_adapters[0]).toBe('toTemplateDataFrame')
-      expect(entry.frontend_import).toContain('toTemplateDataFrame')
-    }
-  })
-
-  it('exposes control schemas for built-in templates and presets', () => {
-    const schemas = listBioTemplateControlSchemas()
-    const plateSchema = getBioTemplateControlSchema('wellplate')
-    const presetSchema = getBioTemplateControlSchema('wellplate-screen')
-    const defaults = getBioTemplateControlDefaults('lcms-batch')
-    const targetedDefaults = getBioTemplateControlDefaults('targeted-metabolomics')
-    const elisaDefaults = getBioTemplateControlDefaults('elisa-assay')
-    const flowDefaults = getBioTemplateControlDefaults('flow-cytometry-assay')
-    const westernDefaults = getBioTemplateControlDefaults('western-blot-assay')
-
-    expect(Object.keys(schemas)).toContain('plate-map')
-    expect(plateSchema?.plateFormat.default).toBe(96)
-    expect(presetSchema?.replicates.default).toBe(3)
-    expect(defaults.instrument).toBe('LC-MS')
-    expect(defaults.featureNames).toEqual(['Glucose', 'Lactate'])
-    expect(targetedDefaults.metaboliteNames).toEqual(['Glucose', 'Lactate', 'Pyruvate'])
-    expect(targetedDefaults.internalStandards).toEqual(['Stable isotope internal standard mix'])
-    expect(targetedDefaults.method).toBe('Targeted metabolomics')
-    expect(elisaDefaults.analyte).toBe('Analyte')
-    expect(elisaDefaults.standardConcentrations).toEqual(['1000', '100', '10', '1'])
-    expect(flowDefaults.markers).toEqual(['CD3', 'CD4', 'CD8'])
-    expect(flowDefaults.includeDefaultControls).toBe(true)
-    expect(westernDefaults.targets).toEqual(['Target protein'])
-    expect(westernDefaults.loadingControl).toBe('ACTB')
-  })
-
-  it('exposes component bindings for template-driven frontend rendering', () => {
-    const bindings = listBioTemplateComponentBindings()
-    const wellplateBindings = getBioTemplateComponentBindings('wellplate-screen')
-    const qpcrBindings = getBioTemplateComponentBindings('gene expression')
-    const elisaBindings = getBioTemplateComponentBindings('elisa-assay')
-    const flowBindings = getBioTemplateComponentBindings('flow-cytometry-assay')
-    const lcmsBindings = getBioTemplateComponentBindings('lcms-batch')
-    const targetedBindings = getBioTemplateComponentBindings('targeted-metabolomics')
-    const westernBindings = getBioTemplateComponentBindings('western-blot-assay')
-    const wellplateImports = toBioTemplateComponentImports('wellplate-screen')
-
-    expect(bindings['plate-map'].map(binding => binding.component)).toEqual(['PlateEditor', 'WellPlate'])
-    expect(wellplateBindings.map(binding => binding.component)).toContain('DoseCalculator')
-    expect(wellplateBindings.map(binding => binding.component)).toContain('WellPlate')
-    expect(qpcrBindings.map(binding => binding.component)).toContain('WellPlate')
-    expect(qpcrBindings.map(binding => binding.component)).toContain('DataFrame')
-    expect(elisaBindings.map(binding => binding.component)).toContain('PlateEditor')
-    expect(elisaBindings.map(binding => binding.component)).toContain('DataFrame')
-    expect(lcmsBindings.map(binding => binding.component)).toContain('ScheduleCalendar')
-    expect(lcmsBindings.map(binding => binding.component)).toContain('ExperimentTimeline')
-    expect(targetedBindings.map(binding => binding.component)).toContain('ReagentList')
-    expect(targetedBindings.map(binding => binding.component)).toContain('DataFrame')
-    expect(targetedBindings.map(binding => binding.component)).toContain('ScheduleCalendar')
-    expect(flowBindings.map(binding => binding.template_id)).toEqual([
-      'sample-sheet',
-      'sample-sheet',
-      'flow-cytometry-panel',
-      'assay-matrix',
-      'assay-matrix',
-    ])
-    expect(westernBindings.map(binding => binding.component)).toContain('ReagentList')
-    expect(westernBindings.map(binding => binding.component)).toContain('ExperimentTimeline')
-    expect(wellplateImports).toEqual([
-      {
-        importPath: '@morscherlab/mint-sdk',
-        components: ['PlateEditor', 'WellPlate', 'DataFrame', 'SampleSelector', 'DoseCalculator'],
-        statement: "import { PlateEditor, WellPlate, DataFrame, SampleSelector, DoseCalculator } from '@morscherlab/mint-sdk'",
-      },
-    ])
-  })
-
-  it('creates plate-map envelopes and adapts them to plate editor state', () => {
-    const template = createPlateMapTemplate({
-      name: 'Drug screen plate',
-      samples: ['DMSO', 'Drug A'],
-    })
-    const state = toPlateMapEditorState(template)
-
-    expect(template.template_id).toBe('plate-map')
-    expect(state.activePlateId).toBe('plate-1')
-    expect(state.plates[0].format).toBe(96)
-    expect(state.samples[1].id).toBe('drug-a')
-  })
-
-  it('should convert plate-map state into PlateEditor racks', () => {
-    const state = toPlateMapEditorState(createPlateMapTemplate({ samples: ['DMSO'] }))
-
-    expect(racksFromPlateState(state)[0]).toMatchObject({ id: 'plate-1', format: 96, slot: 'R' })
-  })
-
-  it('loads the shared plate-map fixture', () => {
-    const state = toPlateMapEditorState(plateMapFixture as PlateMapTemplate)
-    const wells = toWellPlateWells(plateMapFixture as PlateMapTemplate)
-    const componentProps = toBioTemplateComponentProps(plateMapFixture as PlateMapTemplate)
-    const componentBindings = toBioTemplateComponentBindings(plateMapFixture as PlateMapTemplate)
-    const componentPropsById = toBioTemplateComponentPropsById(plateMapFixture as PlateMapTemplate)
-    const componentBindingsById = toBioTemplateComponentBindingsById(plateMapFixture as PlateMapTemplate)
-    const wellPlate = componentProps.find(binding => binding.component === 'WellPlate')
-    const wellPlateBinding = componentBindings.find(binding => binding.component === 'WellPlate')
-
-    expect(state.plates[0].name).toBe('Drug screen plate')
-    expect(wells.A2.sampleType).toBe('drug-a')
-    expect(wellPlate?.propsObject.format).toBe(96)
-    expect((wellPlate?.propsObject.wells as Record<string, { sampleType?: string }>).A2.sampleType).toBe('drug-a')
-    expect(wellPlateBinding?.props.format).toBe(96)
-    expect(wellPlateBinding?.propNames).toContain('wells')
-    expect(componentPropsById['plate-map:WellPlate']).toEqual(wellPlate?.propsObject)
-    expect(componentBindingsById['plate-map:WellPlate'].component).toBe('WellPlate')
-    expect(componentBindingsById['plate-map:WellPlate'].props).toEqual(wellPlate?.propsObject)
-    expect((componentPropsById['plate-map:WellPlate'].wells as Record<string, { sampleType?: string }>).A2.sampleType).toBe('drug-a')
-  })
-
-  it('returns component props keyed by stable template component id', () => {
-    const collection = createWellPlateScreenCollection({
-      samples: ['Control', 'Treatment'],
-      compounds: { 'Drug A': [10, 1] },
-    })
-    const propsById = toBioTemplateComponentPropsById(collection)
-    const bindingsById = toBioTemplateComponentBindingsById(collection)
-    const propsByComponent = toBioTemplateComponentPropsByComponent(collection)
-    const doseCalculatorProps = getBioTemplateComponentProps(collection, 'DoseCalculator')
-    const doseWellPlateProps = getBioTemplateComponentProps(collection, 'WellPlate', {
-      templateId: 'dose-response',
-    })
-
-    expect(Object.keys(propsById)).toEqual([
-      'plate-map:PlateEditor',
-      'plate-map:WellPlate',
-      'sample-sheet:DataFrame',
-      'sample-sheet:SampleSelector',
-      'dose-response:DoseCalculator',
-      'dose-response:WellPlate',
-    ])
-    expect(propsById['dose-response:DoseCalculator'].mode).toBe('serial')
-    expect(bindingsById['dose-response:DoseCalculator'].props.mode).toBe('serial')
-    expect(bindingsById['dose-response:DoseCalculator'].propNames).toContain('mode')
-    expect(propsById['plate-map:WellPlate'].wells).toBeDefined()
-    expect(propsById['dose-response:WellPlate'].wells).toBeDefined()
-    expect(propsByComponent.WellPlate).toHaveLength(2)
-    expect(propsByComponent.DoseCalculator[0].mode).toBe('serial')
-    expect(doseCalculatorProps?.mode).toBe('serial')
-    expect(doseWellPlateProps?.wells).toBeDefined()
-    expect(getBioTemplateComponentProps(collection, 'MissingWidget')).toBeUndefined()
-  })
-
-  it('creates ELISA assay preset collections with plate, standards, and readout matrix', () => {
-    const collection = createElisaAssayCollection({
-      samples: ['Control', 'Treatment'],
-      analyte: 'IL-6',
-      standardConcentrations: [1000, 100, 10, 1],
-      unit: 'pg/mL',
-    })
-    const templates = extractTemplateCollection(collection)
-    const componentPropsById = toBioTemplateComponentPropsById(collection)
-
-    expect(Object.keys(templates)).toEqual([
-      'plate-map',
-      'sample-sheet',
-      'calibration-curve',
-      'assay-matrix',
-    ])
-    expect(collection.metadata?.preset).toBe('elisa-assay')
-    expect(templates['calibration-curve'].data).toMatchObject({
-      analyte: 'IL-6',
-      model: 'four-parameter-logistic',
-      xUnit: 'pg/mL',
-      responseUnit: 'OD450',
-    })
-    expect(templates['assay-matrix'].data).toMatchObject({
-      features: [{ id: 'il-6', name: 'IL-6', type: 'protein', unit: 'OD450', metadata: {} }],
-    })
-    expect(componentPropsById['plate-map:WellPlate'].wells).toBeDefined()
-    expect(componentPropsById['calibration-curve:DataFrame'].data).toBeDefined()
-    expect(componentPropsById['assay-matrix:DataFrame'].columns).toBeDefined()
-    expect(componentPropsById['assay-matrix:SampleSelector'].samples).toEqual(['Control', 'Treatment'])
-  })
-
-  it('generates Vue snippets for concrete template component props', () => {
-    const snippets = toBioTemplateComponentSnippets(plateMapFixture as PlateMapTemplate, {
-      propsVariable: 'bindings',
-    })
-
-    expect(snippets.map(snippet => snippet.component)).toEqual(['PlateEditor', 'WellPlate'])
-    expect(snippets.map(snippet => snippet.propsName)).toEqual([
-      'plateMapPlateEditorProps',
-      'plateMapWellPlateProps',
-    ])
-    expect(snippets[0].propsExpression).toBe('bindings[0].propsObject')
-    expect(snippets[0].template).toBe('<PlateEditor v-bind="bindings[0].propsObject" />')
-    expect(snippets[1].template).toBe('<WellPlate v-bind="bindings[1].propsObject" />')
-  })
-
-  it('generates a Vue usage bundle for concrete template component props', () => {
-    const usage = toBioTemplateComponentUsage(plateMapFixture as PlateMapTemplate, {
-      propsVariable: 'bindings',
-      targetExpression: 'plateMap',
-    })
-
-    expect(usage.imports[0].statement).toBe(
-      "import { PlateEditor, WellPlate } from '@morscherlab/mint-sdk'"
-    )
-    expect(usage.componentProps).toHaveLength(2)
-    expect(usage.propsDeclarations).toEqual([
-      'const plateMapPlateEditorProps = bindings[0].propsObject',
-      'const plateMapWellPlateProps = bindings[1].propsObject',
-    ])
-    expect(usage.scriptSetup).toBe([
-      'const bindings = toBioTemplateComponentProps(plateMap)',
-      'const plateMapPlateEditorProps = bindings[0].propsObject',
-      'const plateMapWellPlateProps = bindings[1].propsObject',
-    ].join('\n'))
-    expect(usage.template).toBe([
-      '<PlateEditor v-bind="plateMapPlateEditorProps" />',
-      '<WellPlate v-bind="plateMapWellPlateProps" />',
-    ].join('\n'))
-  })
-
-  it('generates a complete Vue SFC for concrete template component props', () => {
-    const usage = toBioTemplateComponentUsage(plateMapFixture as PlateMapTemplate)
-
-    expect(usage.scriptSetup).toContain(
-      'const props = defineProps<{ templateCollection: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope }>()'
-    )
-    expect(usage.sfc).toContain("import { PlateEditor, WellPlate } from '@morscherlab/mint-sdk'")
-    expect(usage.sfc).toContain("import { toBioTemplateComponentProps } from '@morscherlab/mint-sdk/templates'")
-    expect(usage.sfc).toContain('defineProps<{ templateCollection: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope }>()')
-    expect(usage.sfc).toContain('<PlateEditor v-bind="plateMapPlateEditorProps" />')
-    expect(usage.sfc).toContain('<WellPlate v-bind="plateMapWellPlateProps" />')
-    expect(usage.sfc).toMatch(/^<script setup lang="ts">[\s\S]*<\/template>$/)
-  })
-
-  it('rejects mismatched template envelopes', () => {
-    expect(() => assertTemplateEnvelope(plateMapFixture, 'sample-sheet')).toThrow(
-      "Expected template_id 'sample-sheet'"
-    )
-  })
-
-  it('returns validated typed template envelopes', () => {
-    const template = ensureTemplateEnvelope<PlateMapTemplate>(plateMapFixture, 'plate-map')
-
-    expect(template.data.plates[0].id).toBe('plate-1')
-    expect(() => ensureTemplateEnvelope<SampleSheetTemplate>(plateMapFixture, 'sample-sheet')).toThrow(
-      "Expected template_id 'sample-sheet'"
-    )
-  })
-
-  it('builds and reads template collections', () => {
-    const plate = createPlateMapTemplate({
-      name: 'Drug screen plate',
-      samples: ['DMSO', 'Drug A'],
-    })
-    const sampleSheet = createSampleSheetTemplate({
-      samples: [
-        { sampleId: 'S001', name: 'Control 1', group: 'Control' },
-      ],
-    })
-    const collection = createTemplateCollection([plate, sampleSheet], { source: 'unit-test' })
-    const extracted = extractTemplateCollection(collection)
-    const typedPlate = ensureTemplateFromCollection<PlateMapTemplate>(collection, 'plate-map')
-
-    expect(Object.keys(collection[TEMPLATE_COLLECTION_KEY])).toEqual(['plate-map', 'sample-sheet'])
-    expect(collection.metadata?.source).toBe('unit-test')
-    expect(extracted['sample-sheet'].template_id).toBe('sample-sheet')
-    expect(typedPlate.data.plates[0].name).toBe('Drug screen plate')
-    expect(extractTemplateCollection(plate)['plate-map'].template_id).toBe('plate-map')
-    expect(() => ensureTemplateFromCollection<SampleSheetTemplate>(collection, 'sample-prep')).toThrow(
-      "Template 'sample-prep' was not found"
-    )
-    expect(() => extractTemplateCollection({ templates: { 'sample-sheet': plate } })).toThrow(
-      'does not match envelope template_id'
-    )
-    expect(() => createTemplateCollection([plate, plate])).toThrow('Duplicate template_id')
-  })
-
-  it('creates ready-to-save template preset collections', () => {
-    const wellplate = createWellPlateScreenCollection({
-      samples: ['Control', 'Treatment'],
-      compounds: { 'Drug A': [10, 1, 0.1] },
-      unit: 'uM',
-    })
-    const qpcr = createQpcrExpressionCollection({
-      samples: [{ sampleId: 'S001', name: 'Control', group: 'Control' }],
-      targets: ['ACTB'],
-    })
-    const lcms = createLcmsBatchCollection({
-      samples: ['S001', 'S002'],
-      features: ['Glucose'],
-      instrument: 'LC-MS',
-    })
-    const targeted = createTargetedMetabolomicsCollection({
-      samples: ['S001', 'S002'],
-      metabolites: ['Glucose', 'Lactate'],
-      internalStandards: ['13C Glucose'],
-      standardConcentrations: [0.1, 1, 10],
-      instrument: 'Orbitrap',
-    })
-    const flow = createFlowCytometryAssayCollection({
-      samples: ['Control', 'Treatment'],
-      markers: ['CD3', 'CD4'],
-      instrument: 'BD LSRFortessa',
-    })
-    const western = createWesternBlotAssayCollection({
-      samples: ['Control', 'Treatment'],
-      targets: ['pERK', 'ERK'],
-      loadingControl: 'ACTB',
-    })
-
-    const wellplateTemplates = extractTemplateCollection(wellplate)
-    const qpcrTemplates = extractTemplateCollection(qpcr)
-    const lcmsTemplates = extractTemplateCollection(lcms)
-    const targetedTemplates = extractTemplateCollection(targeted)
-    const flowTemplates = extractTemplateCollection(flow)
-    const westernTemplates = extractTemplateCollection(western)
-    const wellplateComponentProps = toBioTemplateComponentProps(wellplate)
-
-    expect(Object.keys(wellplateTemplates)).toEqual(['plate-map', 'sample-sheet', 'dose-response'])
-    expect(wellplate.metadata?.preset).toBe('wellplate-screen')
-    expect(toPlateMapEditorState(wellplateTemplates['plate-map'] as PlateMapTemplate).samples[1].id).toBe('treatment')
-    expect(toDoseConditions(wellplateTemplates['dose-response'] as DoseResponseTemplate)[0].label).toBe('Drug A')
-    expect(wellplateComponentProps.map(binding => binding.component)).toContain('PlateEditor')
-    expect(wellplateComponentProps.map(binding => binding.component)).toContain('DoseCalculator')
-    expect(Object.keys(qpcrTemplates)).toEqual(['sample-sheet', 'qpcr-plate'])
-    expect(toQpcrRows(qpcrTemplates['qpcr-plate'] as QpcrPlateTemplate)[0].sampleId).toBe('S001')
-    expect(Object.keys(lcmsTemplates)).toEqual(['sample-sheet', 'instrument-run', 'assay-matrix'])
-    expect(toInstrumentRunRows(lcmsTemplates['instrument-run'] as InstrumentRunTemplate)[0].kind).toBe('blank')
-    expect(toInstrumentRunRows(lcmsTemplates['instrument-run'] as InstrumentRunTemplate)[2].sampleId).toBe('s001')
-    expect(toTemplateDataFrame(lcmsTemplates['assay-matrix']).columns.map(column => column.key)).toContain('glucose')
-    expect(toAssayMatrixSampleOptions(lcmsTemplates['assay-matrix'] as AssayMatrixTemplate).map(option => option.label)).toEqual(['S001', 'S002'])
-    expect(Object.keys(targetedTemplates)).toEqual([
-      'sample-sheet',
-      'sample-prep',
-      'reagent-list',
-      'instrument-run',
-      'calibration-curve',
-      'assay-matrix',
-    ])
-    expect(targeted.metadata?.preset).toBe('targeted-metabolomics')
-    expect(toReagentDataFrame(targetedTemplates['reagent-list'] as ReagentListTemplate).data[0].kind).toBe('compound')
-    expect(toTemplateDataFrame(targetedTemplates['calibration-curve']).data[0].role).toBe('blank')
-    expect(toInstrumentRunRows(targetedTemplates['instrument-run'] as InstrumentRunTemplate).map(row => row.kind)).toEqual([
-      'blank',
-      'standard',
-      'standard',
-      'standard',
-      'qc',
-      'qc',
-      'sample',
-      'sample',
-    ])
-    expect(toTemplateDataFrame(targetedTemplates['assay-matrix']).columns.map(column => column.key)).toContain('lactate')
-    expect(Object.keys(flowTemplates)).toEqual(['sample-sheet', 'flow-cytometry-panel', 'assay-matrix'])
-    expect(flow.metadata?.preset).toBe('flow-cytometry-assay')
-    expect(flowTemplates['flow-cytometry-panel'].data).toMatchObject({
-      instrument: 'BD LSRFortessa',
-      markers: [
-        { id: 'cd3', marker: 'CD3' },
-        { id: 'cd4', marker: 'CD4' },
-      ],
-    })
-    expect(toTemplateDataFrame(flowTemplates['assay-matrix']).columns.map(column => column.key)).toContain('cd4')
-    expect(Object.keys(westernTemplates)).toEqual(['sample-sheet', 'reagent-list', 'protocol-steps', 'assay-matrix'])
-    expect(western.metadata?.preset).toBe('western-blot-assay')
-    expect(toReagentDataFrame(westernTemplates['reagent-list'] as ReagentListTemplate).data[0].kind).toBe('antibody')
-    expect(toProtocolDataFrame(westernTemplates['protocol-steps'] as ProtocolStepsTemplate).data[2].name).toBe('Transfer to membrane')
-    expect(toTemplateDataFrame(westernTemplates['assay-matrix']).columns.map(column => column.key)).toContain('actb')
-
-    const aliasCollection = createBioTemplatePresetCollection('wellplate', {
-      samples: ['Control', 'Treatment'],
-      compounds: { 'Drug A': [10, 1] },
-    })
-    expect(aliasCollection.metadata?.preset).toBe('wellplate-screen')
-    expect(Object.keys(extractTemplateCollection(aliasCollection))).toEqual(['plate-map', 'sample-sheet', 'dose-response'])
-    expect(createBioTemplatePresetCollection('facs').metadata?.preset).toBe('flow-cytometry-assay')
-    expect(createBioTemplatePresetCollection('immunoblot').metadata?.preset).toBe('western-blot-assay')
-    expect(createBioTemplatePresetCollection('targeted metabolomics').metadata?.preset).toBe('targeted-metabolomics')
-    expect(() => createBioTemplatePresetCollection('unknown-preset')).toThrow("Unknown template preset 'unknown-preset'.")
-  })
-
-  it('maps preset control values into template collection previews', () => {
-    const wellplateOptions = bioTemplatePresetControlValuesToOptions('wellplate-screen', {
-      sampleNames: 'Vehicle, Drug A, Drug B',
-      plateName: 'Custom screen',
-      plateFormat: '384',
-      unit: 'nM',
-      replicates: '2',
-    })
-    const wellplate = createBioTemplatePresetCollectionFromControls('wellplate-screen', {
-      sampleNames: 'Vehicle, Drug A, Drug B',
-      plateName: 'Custom screen',
-      plateFormat: '384',
-      unit: 'nM',
-      replicates: '2',
-    })
-    const wellplateTemplates = extractTemplateCollection(wellplate)
-    const plate = wellplateTemplates['plate-map'] as PlateMapTemplate
-    const dose = wellplateTemplates['dose-response'] as DoseResponseTemplate
-
-    expect(wellplateOptions.samples).toEqual(['Vehicle', 'Drug A', 'Drug B'])
-    expect(wellplateOptions.plateFormat).toBe(384)
-    expect(wellplateOptions.replicates).toBe(2)
-    expect(plate.data.plates[0].name).toBe('Custom screen')
-    expect(plate.data.plates[0].format).toBe(384)
-    expect(plate.data.samples.map(sample => sample.id)).toEqual(['vehicle', 'drug-a', 'drug-b'])
-    expect(dose.data.unit).toBe('nM')
-    expect(dose.data.replicates).toBe(2)
-
-    const qpcrOptions = bioTemplatePresetControlValuesToOptions('qpcr-expression', {
-      sampleNames: ['Control', 'Knockdown'],
-      targets: 'ACTB, MYC',
-      chemistry: 'taqman',
-      plateFormat: 384,
-      includeNoTemplateControls: false,
-      replicates: 2,
-      instrument: 'QuantStudio',
-    })
-    const qpcr = ensureTemplateFromCollection<QpcrPlateTemplate>(
-      createBioTemplatePresetCollectionFromControls('qpcr-expression', {
-        sampleNames: ['Control', 'Knockdown'],
-        targets: 'ACTB, MYC',
-        chemistry: 'taqman',
-        plateFormat: 384,
-        includeNoTemplateControls: false,
-        replicates: 2,
-        instrument: 'QuantStudio',
-      }),
-      'qpcr-plate',
-    )
-
-    expect(qpcrOptions.targets).toEqual(['ACTB', 'MYC'])
-    expect(qpcrOptions.includeNoTemplateControls).toBe(false)
-    expect(qpcr.data.chemistry).toBe('taqman')
-    expect(qpcr.data.format).toBe(384)
-    expect(qpcr.data.instrument).toBe('QuantStudio')
-    expect(qpcr.data.reactions).toHaveLength(8)
-    expect(qpcr.data.reactions.some(reaction => reaction.controlKind === 'no-template')).toBe(false)
-
-    const lcmsOptions = bioTemplatePresetControlValuesToOptions('lcms-batch', {
-      sampleNames: 'S001, S002',
-      featureNames: 'Glucose, Pyruvate',
-      instrument: 'Orbitrap',
-      method: 'Polar metabolites',
-      includeQc: false,
-    })
-    const lcmsTemplates = extractTemplateCollection(
-      createBioTemplatePresetCollectionFromControls('lcms-batch', {
-        sampleNames: 'S001, S002',
-        featureNames: 'Glucose, Pyruvate',
-        instrument: 'Orbitrap',
-        method: 'Polar metabolites',
-        includeQc: false,
-      }),
-    )
-    const run = lcmsTemplates['instrument-run'] as InstrumentRunTemplate
-
-    expect(lcmsOptions.features).toEqual(['Glucose', 'Pyruvate'])
-    expect(lcmsOptions.includeQc).toBe(false)
-    expect(run.data.instrument).toBe('Orbitrap')
-    expect(run.data.methods[0].name).toBe('Polar metabolites')
-    expect(run.data.items.map(item => item.kind)).toEqual(['blank', 'sample', 'sample'])
-    expect(toTemplateDataFrame(lcmsTemplates['assay-matrix']).columns.map(column => column.key)).toContain('pyruvate')
-
-    const targetedOptions = bioTemplatePresetControlValuesToOptions('targeted-metabolomics', {
-      sampleNames: 'QC Pool, Patient A',
-      metaboliteNames: 'Glucose, Citrate',
-      internalStandards: '13C Glucose',
-      standardConcentrations: '0.5, 5, 50',
-      concentrationUnit: 'nM',
-      responseUnit: 'area ratio',
-      instrument: 'Triple quadrupole',
-      method: 'MRM panel',
-      outputVolume: '25',
-      includeQc: false,
-    })
-    const targetedTemplates = extractTemplateCollection(
-      createBioTemplatePresetCollectionFromControls('targeted-metabolomics', {
-        sampleNames: 'QC Pool, Patient A',
-        metaboliteNames: 'Glucose, Citrate',
-        internalStandards: '13C Glucose',
-        standardConcentrations: '0.5, 5, 50',
-        concentrationUnit: 'nM',
-        responseUnit: 'area ratio',
-        instrument: 'Triple quadrupole',
-        method: 'MRM panel',
-        outputVolume: '25',
-        includeQc: false,
-      }),
-    )
-    const targetedRun = targetedTemplates['instrument-run'] as InstrumentRunTemplate
-
-    expect(targetedOptions.metabolites).toEqual(['Glucose', 'Citrate'])
-    expect(targetedOptions.standardConcentrations).toEqual([0.5, 5, 50])
-    expect(targetedOptions.outputVolume).toBe(25)
-    expect(targetedRun.data.instrument).toBe('Triple quadrupole')
-    expect(targetedRun.data.methods[0].name).toBe('MRM panel')
-    expect(targetedRun.data.items.map(item => item.kind)).toEqual([
-      'blank',
-      'standard',
-      'standard',
-      'standard',
-      'sample',
-      'sample',
-    ])
-    expect(toTemplateDataFrame(targetedTemplates['assay-matrix']).columns.map(column => column.key)).toContain('citrate')
-
-    const flowOptions = bioTemplatePresetControlValuesToOptions('flow-cytometry-assay', {
-      sampleNames: 'Control, Treatment',
-      markers: 'CD3, CD19',
-      featureNames: 'T cells, B cells',
-      instrument: 'Cytek Aurora',
-      includeDefaultControls: false,
-    })
-    const flowTemplates = extractTemplateCollection(
-      createBioTemplatePresetCollectionFromControls('flow-cytometry-assay', {
-        sampleNames: 'Control, Treatment',
-        markers: 'CD3, CD19',
-        featureNames: 'T cells, B cells',
-        instrument: 'Cytek Aurora',
-        includeDefaultControls: false,
-      }),
-    )
-    const flowPanel = flowTemplates['flow-cytometry-panel'] as FlowCytometryPanelTemplate
-
-    expect(flowOptions.markers).toEqual(['CD3', 'CD19'])
-    expect(flowOptions.features).toEqual(['T cells', 'B cells'])
-    expect(flowPanel.data.instrument).toBe('Cytek Aurora')
-    expect(flowPanel.data.controls).toEqual([])
-    expect(toTemplateDataFrame(flowTemplates['assay-matrix']).columns.map(column => column.key)).toContain('b-cells')
-
-    const westernOptions = bioTemplatePresetControlValuesToOptions('western-blot-assay', {
-      sampleNames: 'Control, Treatment',
-      targets: 'pERK, ERK',
-      loadingControl: 'ACTB',
-    })
-    const westernTemplates = extractTemplateCollection(
-      createBioTemplatePresetCollectionFromControls('western-blot-assay', {
-        sampleNames: 'Control, Treatment',
-        targets: 'pERK, ERK',
-        loadingControl: 'ACTB',
-      }),
-    )
-
-    expect(westernOptions.targets).toEqual(['pERK', 'ERK'])
-    expect(westernOptions.loadingControl).toBe('ACTB')
-    expect(toProtocolSteps(westernTemplates['protocol-steps'] as ProtocolStepsTemplate).map(step => step.name)).toContain('Run SDS-PAGE')
-    expect(toTemplateDataFrame(westernTemplates['assay-matrix']).columns.map(column => column.key)).toContain('actb')
-  })
-
-  it('creates sample-sheet templates and adapts rows, columns, and options', () => {
-    const template = createSampleSheetTemplate({
-      samples: [
-        {
-          sampleId: 'S001',
-          name: 'Control 1',
-          group: 'Control',
-          metadata: { cell_line: 'HCT116' },
-        },
-        {
-          sampleId: 'S002',
-          name: 'Control 2',
-          group: 'Control',
-        },
-      ],
-      columns: [
-        { id: 'sampleId', label: 'Sample ID', type: 'string', required: true, groupable: false },
-        { id: 'cell_line', label: 'Cell Line', type: 'string', required: false, groupable: true },
-      ],
-    })
-
-    expect(toSampleRows(template)[0].cell_line).toBe('HCT116')
-    expect(template.data.samples[1].metadata).toEqual({})
-    expect(toSampleColumns(template)[0].key).toBe('sampleId')
-    expect(toSampleColumns(template)[1].key).toBe('cell_line')
-    const sampleFrame = toSampleDataFrame(template)
-    expect(sampleFrame.rowKey).toBe('sampleId')
-    expect(sampleFrame.data[0].cell_line).toBe('HCT116')
-    expect(sampleFrame.columns.map(column => column.key)).toEqual(['sampleId', 'cell_line'])
-    expect(toTemplateDataFrame(template).rowKey).toBe('sampleId')
-    expect(toSampleOptions(template)[0].label).toBe('Control 1')
-  })
-
-  it('loads the shared sample-sheet fixture', () => {
-    const rows = toSampleRows(sampleSheetFixture as SampleSheetTemplate)
-    const columns = toSampleColumns(sampleSheetFixture as SampleSheetTemplate)
-    const options = toSampleOptions(sampleSheetFixture as SampleSheetTemplate)
-
-    expect(rows[1].group).toBe('Drug A')
-    expect(columns[0].key).toBe('sampleId')
-    expect(options[0].value).toBe('S001')
-  })
-
-  it('creates sample-prep templates and adapts prep steps', () => {
-    const template = createSamplePrepTemplate({
-      samples: ['S001', { name: 'Dilute S002', sourceSampleId: 'S002', type: 'dilution' }],
-      prepType: 'extraction',
-      outputVolume: 50,
-    })
-    const rows = toSamplePrepRows(template)
-    const frame = toSamplePrepDataFrame(template)
-
-    expect(template.template_id).toBe('sample-prep')
-    expect(rows[0].sourceSampleId).toBe('s001')
-    expect(rows[0].destinationSampleId).toBe('s001-prepared')
-    expect(rows[0].outputVolume).toBe(50)
-    expect(rows[1].id).toBe('dilute-s002')
-    expect(frame.rowKey).toBe('id')
-    expect(frame.columns.map(column => column.key)).toContain('status')
-    expect(toTemplateDataFrame(template).data[1].type).toBe('dilution')
-  })
-
-  it('creates dose-response templates and adapts dose conditions', () => {
-    const template = createDoseResponseTemplate({
-      compounds: { 'Drug A': [0.1, 10, 1] },
-      unit: 'uM',
-      replicates: 2,
-    })
-    const conditions = toDoseConditions(template)
-
-    expect(template.template_id).toBe('dose-response')
-    expect(template.data.compounds[0].concentrations).toEqual([10, 1, 0.1])
-    expect(conditions[0].unit).toBe('uM')
-    expect(conditions[0].concentrations).toEqual([10, 1, 0.1])
-  })
-
-  it('defaults metadata for explicit template records', () => {
-    const samplePrep = createSamplePrepTemplate({
-      samples: [{ name: 'Extract S001', sourceSampleId: 'S001' }],
-    })
-    const doseResponse = createDoseResponseTemplate({
-      compounds: [{ id: 'drug-a', name: 'Drug A', concentrations: [1, 0.1] }],
-      unit: 'uM',
-      controls: [{ id: 'vehicle', name: 'DMSO', role: 'vehicle' }],
-    })
-    const timeCourse = createTimeCourseTemplate({
-      timepoints: [{ id: 't0-hour', label: '0 hour', value: 0, unit: 'hour' }],
-      unit: 'hour',
-      conditions: [{ id: 'control', name: 'Control' }],
-    })
-    const assayMatrix = createAssayMatrixTemplate({
-      samples: [{ sampleId: 'S001', name: 'Control 1' }],
-      features: [{ id: 'lactate', name: 'Lactate', type: 'metabolite' }],
-    })
-
-    expect(samplePrep.data.steps[0].metadata).toEqual({})
-    expect(doseResponse.data.compounds[0].metadata).toEqual({})
-    expect(doseResponse.data.controls[0].metadata).toEqual({})
-    expect(timeCourse.data.timepoints[0].metadata).toEqual({})
-    expect(timeCourse.data.conditions[0].metadata).toEqual({})
-    expect(assayMatrix.data.samples[0].metadata).toEqual({})
-    expect(assayMatrix.data.features[0].metadata).toEqual({})
-    expect(toDoseConditions(doseResponse)[0].color).toBe('#3B82F6')
-    expect(toTimeCourseRows(timeCourse)[0].sampleId).toBe('control-t0-hour-r1')
-    expect(toAssayMatrixRows(assayMatrix)[0].sampleId).toBe('S001')
-  })
-
-  it('loads the shared dose-response fixture with layout', () => {
-    const conditions = toDoseConditions(doseResponseFixture as DoseResponseTemplate)
-    const layout = toDoseLayoutState(doseResponseFixture as DoseResponseTemplate)
-    const componentProps = toBioTemplateComponentProps(doseResponseFixture as DoseResponseTemplate)
-    const doseCalculator = componentProps.find(binding => binding.component === 'DoseCalculator')
-    const wellPlate = componentProps.find(binding => binding.component === 'WellPlate')
-
-    expect(conditions[0].label).toBe('Drug A')
-    expect(layout?.plates[0].wells.A2.value).toBe(10)
-    expect(doseCalculator?.propsObject.mode).toBe('serial')
-    expect((doseCalculator?.propsObject.targetWells as string[])).toContain('A2')
-    expect((wellPlate?.propsObject.wells as Record<string, { value?: number }>).A2.value).toBe(10)
-  })
-
-  it('rejects invalid dose-response data', () => {
-    expect(() => createDoseResponseTemplate({
-      compounds: { 'Drug A': [-1] },
-      unit: 'uM',
-    })).toThrow('negative concentration')
-  })
-
-  it('creates calibration-curve templates and adapts standard curves', () => {
-    const template = createCalibrationCurveTemplate({
-      concentrations: [0.1, { level: 'Standard 2', concentration: 1 }, 10],
-      analyte: 'Glucose',
-      unit: 'uM',
-    })
-    const rows = toCalibrationCurveRows(template)
-    const frame = toCalibrationCurveDataFrame(template)
-
-    expect(template.template_id).toBe('calibration-curve')
-    expect(template.data.points.map(point => point.role)).toEqual([
-      'blank',
-      'standard',
-      'standard',
-      'standard',
-      'qc',
-      'qc',
-    ])
-    expect(rows[2].id).toBe('standard-2')
-    expect(rows[2].analyte).toBe('Glucose')
-    expect(frame.rowKey).toBe('id')
-    expect(frame.columns.map(column => column.key)).toContain('status')
-    expect(toTemplateDataFrame(template).data[0].role).toBe('blank')
-  })
-
-  it('creates time-course templates and adapts samples and steps', () => {
-    const template = createTimeCourseTemplate({
-      timepoints: [24, 0, 6],
-      unit: 'hour',
-      conditions: ['Control', 'Treatment'],
-      replicates: 2,
-    })
-    const rows = toTimeCourseRows(template)
-    const steps = toTimeCourseSteps(template)
-
-    expect(template.template_id).toBe('time-course')
-    expect(template.data.timepoints.map(timepoint => timepoint.id)).toEqual(['t0-hour', 't6-hour', 't24-hour'])
-    expect(rows).toHaveLength(12)
-    expect(toTimeCourseDataFrame(template).columns[0].key).toBe('sampleId')
-    expect(toTemplateDataFrame(template).data).toHaveLength(12)
-    expect(steps[0].type).toBe('measurement')
-  })
-
-  it('creates protocol-step templates and adapts timeline and dataframe props', () => {
-    const template = createProtocolStepsTemplate({
-      steps: [
-        {
-          name: 'Measure readout',
-          type: 'measurement',
-          duration: 45,
-          order: 2,
-        },
-        'Seed cells',
-      ],
-    })
-    const steps = toProtocolSteps(template)
-    const frame = toProtocolDataFrame(template)
-
-    expect(template.template_id).toBe('protocol-steps')
-    expect(steps.map(step => step.name)).toEqual(['Seed cells', 'Measure readout'])
-    expect(steps[1].type).toBe('measurement')
-    expect(frame.rowKey).toBe('id')
-    expect(frame.columns.map(column => column.key)).toContain('duration')
-    expect(toTemplateDataFrame(template).data[0].id).toBe('seed-cells')
-  })
-
-  it('creates assay-matrix templates and adapts pivoted rows and columns', () => {
-    const template = createAssayMatrixTemplate({
-      samples: ['S001', 'S002'],
-      features: ['Lactate', 'Glucose'],
-      values: {
-        s001: { lactate: 1.2, glucose: 5.4 },
-        s002: { lactate: 2.1, glucose: 4.8 },
-      },
-    })
-    const rows = toAssayMatrixRows(template)
-    const columns = toAssayMatrixColumns(template)
-
-    expect(template.template_id).toBe('assay-matrix')
-    expect(rows[0].lactate).toBe(1.2)
-    expect(columns.map(column => column.key)).toContain('glucose')
-    const assayFrame = toAssayMatrixDataFrame(template)
-    expect(assayFrame.rowKey).toBe('sampleId')
-    expect(assayFrame.data[0].lactate).toBe(1.2)
-    expect(toAssayMatrixSampleOptions(template)).toEqual([
-      { value: 's001', label: 'S001', description: undefined },
-      { value: 's002', label: 'S002', description: undefined },
-    ])
-    expect(toTemplateDataFrame(template).columns.map(column => column.key)).toContain('glucose')
-  })
-
-  it('creates reagent-list templates and adapts items and dataframe props', () => {
-    const template = createReagentListTemplate({
-      reagents: [
-        {
-          id: 'dmso',
-          name: 'DMSO',
-          kind: 'compound',
-          storageCondition: 'RT',
-          stockLevel: 80,
-          stockUnit: '%',
-        },
-        'Anti-HA antibody',
-      ],
-    })
-    const items = toReagentListItems(template)
-    const frame = toReagentDataFrame(template)
-
-    expect(template.template_id).toBe('reagent-list')
-    expect(items[0].name).toBe('DMSO')
-    expect(items[0].storageCondition).toBe('RT')
-    expect(template.data.reagents[1].id).toBe('anti-ha-antibody')
-    expect(frame.rowKey).toBe('id')
-    expect(frame.columns.map(column => column.key)).toContain('stockLevel')
-    expect(toTemplateDataFrame(template).data[0].kind).toBe('compound')
-  })
-
-  it('creates flow-cytometry panel templates and adapts marker rows', () => {
-    const template = createFlowCytometryPanelTemplate({
-      markers: [
-        { id: 'cd3', marker: 'CD3', fluorophore: 'FITC', detector: 'B530/30' },
-        { id: 'cd4', marker: 'CD4', fluorophore: 'PE', detector: 'B585/42' },
-      ],
-      instrument: 'BD LSRFortessa',
-    })
-    const rows = toFlowPanelRows(template)
-    const frame = toFlowPanelDataFrame(template)
-
-    expect(template.template_id).toBe('flow-cytometry-panel')
-    expect(template.data.controls.map(control => control.kind)).toContain('single-stain')
-    expect(rows[0].marker).toBe('CD3')
-    expect(rows[0].controls).toContain('CD3 single stain')
-    expect(frame.rowKey).toBe('id')
-    expect(frame.columns.map(column => column.key)).toContain('fluorophore')
-    expect(toTemplateDataFrame(template).data[1].detector).toBe('B585/42')
-  })
-
-  it('creates instrument-run templates and adapts run queues', () => {
-    const template = createInstrumentRunTemplate({
-      items: ['S001', { name: 'S002', vial: 'A2' }],
-      instrument: 'LC-MS',
-      method: 'Default method',
-    })
-    const rows = toInstrumentRunRows(template)
-    const frame = toInstrumentRunDataFrame(template)
-    const steps = toInstrumentRunSteps(template)
-    const events = toInstrumentRunScheduleEvents(template)
-    const componentProps = toBioTemplateComponentProps(template)
-    const calendar = componentProps.find(binding => binding.component === 'ScheduleCalendar')
-    const timeline = componentProps.find(binding => binding.component === 'ExperimentTimeline')
-
-    expect(template.template_id).toBe('instrument-run')
-    expect(template.data.items.map(item => item.kind)).toEqual(['blank', 'qc', 'sample', 'sample', 'qc'])
-    expect(rows[0].name).toBe('Blank start')
-    expect(rows[2].sampleId).toBe('s001')
-    expect(rows[3].vial).toBe('A2')
-    expect(frame.rowKey).toBe('id')
-    expect(frame.columns.map(column => column.key)).toContain('status')
-    expect(toTemplateDataFrame(template).data[3].sampleId).toBe('s002')
-    expect(steps[2]).toMatchObject({
-      id: 's001-run',
-      type: 'measurement',
-      name: 'S001',
-      status: 'pending',
-      order: 3,
-    })
-    expect(steps[2].parameters?.method).toBe('Default method')
-    expect(events[0]).toMatchObject({
-      id: 'blank-start',
-      title: 'Blank start',
-      start: '2024-01-01T08:00:00.000Z',
-      end: '2024-01-01T08:10:00.000Z',
-      status: 'pending',
-    })
-    expect(events[2].title).toBe('S001')
-    expect(calendar?.propsObject.modelValue).toBe(events[0].start)
-    expect(calendar?.propsObject.events).toEqual(events)
-    expect(timeline?.propsObject.modelValue).toEqual(steps)
-  })
-
-  it('creates qPCR plate templates and adapts reactions to dataframe and wells', () => {
-    const template = createQpcrPlateTemplate({
-      samples: ['Control', 'Treatment'],
-      targets: ['ACTB', 'GAPDH'],
-      replicates: 2,
-      instrument: 'QuantStudio',
-    })
-    const rows = toQpcrRows(template)
-    const frame = toQpcrDataFrame(template)
-    const wells = toQpcrWellPlateWells(template)
-
-    expect(template.template_id).toBe('qpcr-plate')
-    expect(template.data.reactions).toHaveLength(10)
-    expect(template.data.reactions.at(-1)?.controlKind).toBe('no-template')
-    expect(rows[0].sample).toBe('Control')
-    expect(rows[0].target).toBe('ACTB')
-    expect(frame.rowKey).toBe('id')
-    expect(frame.columns.map(column => column.key)).toContain('cq')
-    expect(wells.A1.sampleType).toBe('control')
-    expect(wells.A1.metadata?.targetId).toBe('actb')
-    expect(toTemplateDataFrame(template).data.at(-1)?.controlKind).toBe('no-template')
-  })
-
-  it('loads the shared qPCR plate fixture', () => {
-    const template = ensureTemplateEnvelope<QpcrPlateTemplate>(qpcrPlateFixture, 'qpcr-plate')
-    const frame = toQpcrDataFrame(template)
-    const wells = toQpcrWellPlateWells(template)
-    const componentProps = toBioTemplateComponentProps(template)
-    const wellPlate = componentProps.find(binding => binding.component === 'WellPlate')
-    const table = componentProps.find(binding => binding.component === 'DataFrame')
-
-    expect(template.data.chemistry).toBe('taqman')
-    expect(frame.data[2].flags).toBe('review')
-    expect(frame.data[3].sample).toBe('no-template')
-    expect(wells.A1.row).toBe(0)
-    expect(wells.A1.col).toBe(0)
-    expect(wells.A4.sampleType).toBe('no-template')
-    expect((wellPlate?.propsObject.wells as Record<string, { sampleType?: string }>).A4.sampleType).toBe('no-template')
-    expect((table?.propsObject.data as Record<string, unknown>[])[0].target).toBe('ACTB')
-  })
-
-  it('rejects templates without a dataframe adapter', () => {
-    expect(() => toTemplateDataFrame(createPlateMapTemplate())).toThrow(
-      "Template 'plate-map' does not expose a DataFrame adapter."
-    )
-    expect(() => toTemplateDataFrame(createDoseResponseTemplate({
-      compounds: { 'Drug A': [1] },
-      unit: 'uM',
-    }))).toThrow("Template 'dose-response' does not expose a DataFrame adapter.")
-  })
-
-  it('accepts assay-matrix display names for values', () => {
-    const template = createAssayMatrixTemplate({
-      samples: ['S001'],
-      features: ['Lactate'],
-      values: {
-        S001: { Lactate: 1.2 },
-      },
-    })
-
-    expect(template.data.measurements[0].sampleId).toBe('s001')
-    expect(template.data.measurements[0].featureId).toBe('lactate')
-  })
-})
-
-describe('plate-map PlateEditor binding (7a)', () => {
-  const editorProps = () =>
-    toBioTemplateComponentProps(plateMapFixture as PlateMapTemplate)
-      .find(binding => binding.component === 'PlateEditor')?.propsObject as Record<string, unknown>
-
-  it('should pass the plates as racks with sequential slots', () => {
-    expect((editorProps().modelValue as Array<{ slot: string }>)[0].slot).toBe('R')
-  })
-
-  it('should move the sample id of a well to its group', () => {
-    const racks = editorProps().modelValue as Array<{ wells: Record<string, { group?: string }> }>
-
-    expect(racks[0].wells.A2.group).toBe('drug-a')
-  })
-
-  it('should make a well with a sample id a sample', () => {
-    const racks = editorProps().modelValue as Array<{ wells: Record<string, { sampleType?: string }> }>
-
-    expect(racks[0].wells.A2.sampleType).toBe('sample')
-  })
-
-  it('should leave the stored plate-map wells unchanged', () => {
-    const template = structuredClone(plateMapFixture) as PlateMapTemplate
-    toBioTemplateComponentProps(template)
-
-    expect(template).toEqual(plateMapFixture)
-  })
-
-  it('should offer the template samples as groups', () => {
-    expect((editorProps().groups as Array<{ id: string }>).map(group => group.id)).toContain('drug-a')
-  })
-
-  it('should pin the format to the plate format', () => {
-    expect(editorProps().formats).toEqual([96])
-  })
-})