@morscherlab/mint-sdk 1.0.0-beta.2 → 1.0.0-beta.4

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

@@ -0,0 +1,1055 @@
+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,
+  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,
+  toCalibrationCurveDataFrame,
+  toCalibrationCurveRows,
+  toDoseConditions,
+  toDoseLayoutState,
+  toFlowPanelDataFrame,
+  toFlowPanelRows,
+  toInstrumentRunDataFrame,
+  toInstrumentRunRows,
+  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 {
+  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('longitudinal')?.init_command).toBe('mint init --template longitudinal-study')
+    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',
+      '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('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('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 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(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 westernBindings = getBioTemplateComponentBindings('western-blot-assay')
+    const wellplateImports = toBioTemplateComponentImports('wellplate-screen')
+
+    expect(bindings['plate-map'].map(binding => binding.component)).toEqual(['PlateMapEditor', '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('PlateMapEditor')
+    expect(elisaBindings.map(binding => binding.component)).toContain('DataFrame')
+    expect(flowBindings.map(binding => binding.template_id)).toEqual([
+      'sample-sheet',
+      'sample-sheet',
+      'flow-cytometry-panel',
+      '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: ['PlateMapEditor', 'WellPlate', 'DataFrame', 'SampleSelector', 'DoseCalculator'],
+        statement: "import { PlateMapEditor, 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('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:PlateMapEditor',
+      '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()
+  })
+
+  it('generates Vue snippets for concrete template component props', () => {
+    const snippets = toBioTemplateComponentSnippets(plateMapFixture as PlateMapTemplate, {
+      propsVariable: 'bindings',
+    })
+
+    expect(snippets.map(snippet => snippet.component)).toEqual(['PlateMapEditor', 'WellPlate'])
+    expect(snippets.map(snippet => snippet.propsName)).toEqual([
+      'plateMapPlateMapEditorProps',
+      'plateMapWellPlateProps',
+    ])
+    expect(snippets[0].propsExpression).toBe('bindings[0].propsObject')
+    expect(snippets[0].template).toBe('<PlateMapEditor 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 { PlateMapEditor, WellPlate } from '@morscherlab/mint-sdk'"
+    )
+    expect(usage.componentProps).toHaveLength(2)
+    expect(usage.propsDeclarations).toEqual([
+      'const plateMapPlateMapEditorProps = bindings[0].propsObject',
+      'const plateMapWellPlateProps = bindings[1].propsObject',
+    ])
+    expect(usage.scriptSetup).toBe([
+      'const bindings = toBioTemplateComponentProps(plateMap)',
+      'const plateMapPlateMapEditorProps = bindings[0].propsObject',
+      'const plateMapWellPlateProps = bindings[1].propsObject',
+    ].join('\n'))
+    expect(usage.template).toBe([
+      '<PlateMapEditor v-bind="plateMapPlateMapEditorProps" />',
+      '<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 { PlateMapEditor, 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('<PlateMapEditor v-bind="plateMapPlateMapEditorProps" />')
+    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 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 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('PlateMapEditor')
+    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(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('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 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(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)
+
+    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')
+  })
+
+  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')
+  })
+})